# HelloWork Jobs Scraper - France Job Offers, Salary & Company (`topapi/hellowork-jobs-scraper`) Actor

Scrape HelloWork job offers in France by keyword, city and every HelloWork filter, or from search, company and job links. Full offer, salary, telework, skills, commune coordinates, company profile, SIREN register match, monitor mode. $0.72 per 1,000 offers.

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

## Pricing

from $0.72 / 1,000 job offers

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

### What does HelloWork Jobs Scraper do?

**HelloWork Jobs Scraper** extracts job offers from [HelloWork](https://www.hellowork.com), one of France's largest job boards (about 800,000 live offers), and returns each offer as one structured row: title, employer, location with département, region and commune coordinates, contract (CDI, CDD, intérim, stage, alternance...), working time, telework, salary (posted or HelloWork's own estimate), dates, skills, education, experience, sector and the full description. Search by keyword and location with every filter of HelloWork's own search form, or paste HelloWork search, listing, company or job links, or job ids. Recruiters, HR-tech and staffing companies, job boards and labour-market analysts use it to pull French job offers into a sheet, a database or an API call.

- 🔎 **Every HelloWork filter**: contract, telework, working time, experience, employer type, job function, sector, radius, posted within, minimum salary, salary published, super recruiters, sort by relevance or date
- 🔗 **Every kind of input**: keywords x locations, HelloWork search URLs, SEO listing pages, company pages (all their active offers), job URLs and job ids
- 📄 **The full offer**: description (text, HTML, Markdown), skills, education, experience, sector, qualifications, valid-through date, reference, application route
- 💶 **Salary you can filter on**: `salaryMin` / `salaryMax` / `salaryPeriod`, a flag when the figure is HelloWork's estimate, and HelloWork's estimate distribution (p10-p90)
- 📍 **Location you can map**: city, postal code (Paris / Lyon / Marseille arrondissements resolved), département, region, latitude, longitude, INSEE code
- 🏢 **Employer add-ons**: the HelloWork company profile (free) and a match in the French company register: SIREN, legal form, NAF code, staff band, directors, turnover
- 🔔 **Monitor mode** for schedules: only offers you have not received, with Slack, Discord, Telegram, WhatsApp or webhook alerts
- 🔓 No login, no cookies, no API key

### What data can you get from HelloWork?

| | | |
|---|---|---|
| 💼 Title, offer id, URL, reference | 🏢 Employer, logo, HelloWork company page | 🏷️ Employer type (ESN, recruitment firm, temp agency), agency flag |
| 📍 City, postal code, département, region | 🗺️ Latitude, longitude, INSEE code | 🏠 Telework (full, partial, occasional, none) |
| 📝 Contract (CDI, CDD, intérim, stage, alternance...) | ⏱️ Working time, contract duration | 💶 Salary min / max / period, estimate flag |
| 📊 HelloWork salary estimate (median, p10-p90) | 📅 Posted date, "posted ago", valid through | 🎓 Education, education level |
| 🧭 Experience asked, minimum months | 🛠️ Skills, qualifications | 🏭 Sector, industry, job function, job family |
| 🔖 HelloWork's keyword tags, all page tags | 📝 Full description (text, HTML, Markdown), snippet | 🎁 Benefits listed in the offer |
| ⭐ Super recruiter, application tracking | 📨 Application route, direct apply | 🔗 Links and social profiles in the offer |
| ➕ Company profile: sector, founded, revenue, staff, telework policy, age, seniority, gender split, socials | ➕ Company register: SIREN, SIRET, legal form, NAF, staff band, head office, directors, turnover, VAT | 🆕 New / updated / unchanged / removed, first seen, reposts |

### How to scrape HelloWork with HelloWork Jobs Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) (it comes with monthly free credit).
2. Open **HelloWork Jobs Scraper** and type one or more **Search keywords**, e.g. `développeur`, `comptable`, `infirmier`.
3. Add a **Location** (`Paris`, `Lyon`, `69`, `Île-de-France`) and any **Filters** you need, or paste HelloWork links in **HelloWork URLs**.
4. Set **Max offers per search** and click **Start**.
5. Download the offers as JSON, CSV, Excel or HTML, or read them through the API.

### ⬇️ Input

Every field is optional. An empty form reads 100 offers from all of France, in HelloWork's default order.

| Parameter | Type | Description |
|---|---|---|
| `searchQueries` | array | Keywords; each one runs its own search (with each location) |
| `location` / `locations` | string / array | City, département or region; several locations = keyword x location searches |
| `radiusKm` | integer | 0, 5, 10, 20 (HelloWork's default) or 50 km around the location |
| `startUrls` | array | HelloWork search URLs, SEO listing pages, company pages, job URLs |
| `jobIds` | array | HelloWork offer ids (the number in `/fr-fr/emplois/<id>.html`) |
| `maxResults` | integer | Offers per search or URL (default 100; 0 = the whole search) |
| `maxTotalResults` / `maxPages` | integer | A cap on the whole run / result pages per search (30 offers a page) |
| `contractTypes` | array | `CDI`, `CDD`, `Travail_temp` (intérim), `Stage`, `Alternance`, `Independant`, `Freelance`, `Franchise`, `Associe`, `Fonctionnaire`, `Stage_de_lycee` |
| `telework` | array | `Complet`, `Partiel`, `Occasionnel`, `Pas_teletravail` |
| `workingTime` | array | `ft` (full time), `pt` (part time), `np` (not stated) |
| `experience` | array | `deb` (beginners welcome), `0-1y`, `2-3y`, `4-5y`, `6-10y`, `gt10y`, `unknown` |
| `employerTypes` | array | `Entreprises`, `Cabinet_recr` (recruitment firms), `SSII` (ESN), `Travail_temporaire`, `Centre_formation` |
| `functions` / `sectors` | array | HelloWork's job-function and sector filters (34 and 26 values) |
| `postedWithin` | string | `all`, `24h`, `3d`, `7d`, `30d` |
| `minSalary` | integer | Minimum gross yearly salary in EUR (HelloWork's filter, up to 100,000) |
| `onlyWithSalary` / `superRecruiterOnly` | boolean | Only offers with a published salary / from super recruiters |
| `sortBy` | string | `relevance` or `date` (newest first) |
| `excludeKeywords` / `excludeCompanies` | array | Skip offers whose title / employer contains these words |
| `skipReposts` | boolean | Skip the same employer + title + place re-posted under a new id |
| `includeDetails` | boolean | Read each offer's page (default on); off = the search card's fields only |
| `includeDescription` / `descriptionFormat` / `descriptionMaxLength` | | Description on/off, `all` / `text` / `html` / `markdown`, cut length |
| `includeCoordinates` | boolean | Commune latitude / longitude / INSEE code (default on, free) |
| `includeCompanyProfile` | boolean | Employer's HelloWork company page (free) |
| `includeCompanyRegistry` | boolean | Employer matched in the French company register (paid add-on) |
| `monitorMode`, `monitorStoreName`, `firstRunMode`, `monitorIncludeUpdated`, `emitUnchanged`, `emitRemovedJobs`, `resetMonitor` | | Only new offers on scheduled runs; see below |
| `webhookUrl`, `webhookHeaders`, `slackWebhookUrl`, `discordWebhookUrl`, `telegramToken` + `telegramChatId`, `whatsappPhoneNumberId` + `whatsappAccessToken` + `whatsappTo`, `notificationLimit` | | Run alerts |
| `compact` / `excludeEmptyFields` | boolean | Core fields only / drop empty fields |
| `maxConcurrency` / `proxyConfiguration` | | Pages read at once (default 10) / your own proxy (not needed) |

Contract, telework and the other filter values also accept plain words (`interim`, `full`, `partial`, `hybrid`, `CDI`...), and the input names of other HelloWork actors (`keywords`, `contractType`, `remote_policy`, `period`, `limit`, `results_wanted`...) are read too.

#### Input JSON

```json
{
  "searchQueries": ["développeur", "data engineer"],
  "location": "Lyon",
  "radiusKm": 20,
  "contractTypes": ["CDI"],
  "telework": ["Partiel", "Complet"],
  "postedWithin": "7d",
  "maxResults": 200,
  "includeCompanyProfile": true
}
```

#### Paste a HelloWork link to reuse the filters you set on the site

Build a search on hellowork.com, copy the address bar and put it in `startUrls`. A company page (`/fr-fr/entreprises/<name>-<id>.html`) returns that employer's active offers; a listing page such as `/fr-fr/emploi/metier_developpeur-ville_lyon-69000.html` returns its offers 20 a page.

### ⬆️ Output

One row per offer. A real row from a run on 2026-11-06 (search `développeur` @ Nantes, both employer add-ons on; long texts cut here):

```json
{
  "jobId": "85201621",
  "jobUrl": "https://www.hellowork.com/fr-fr/emplois/85201621.html",
  "title": "Développeur Salesforce H/F",
  "company": "Akkodis",
  "companyId": "192291",
  "companyUrl": "https://www.hellowork.com/fr-fr/entreprises/akkodis-5159.html",
  "companyLogo": "https://f.hellowork.com/img/entreprises/160_160/192291.png",
  "anonymousCompany": false,
  "companyType": "ESN",
  "isAgency": false,
  "superRecruiter": false,
  "location": "Nantes - 44",
  "city": "Nantes",
  "postalCode": "44000",
  "departmentCode": "44",
  "department": "Loire-Atlantique",
  "region": "Pays de la Loire",
  "country": "France",
  "latitude": 47.2382,
  "longitude": -1.5603,
  "inseeCode": "44109",
  "contractType": "CDI",
  "employmentTypeEnum": "FULL_TIME",
  "workingTime": "Temps plein",
  "salary": "37 500 - 46 200 € / an",
  "salaryMin": 37500,
  "salaryMax": 46200,
  "salaryCurrency": "EUR",
  "salaryPeriod": "YEAR",
  "salaryIsEstimate": true,
  "salaryEstimate": { "median": 42500, "percentile10": 31504, "percentile25": 37500, "percentile75": 46200, "percentile90": 52500, "currency": "EUR", "period": "YEAR" },
  "datePosted": "2026-11-05T16:25:14Z",
  "postedAgo": "il y a 16 heures",
  "validThrough": "2026-12-05T16:25:14Z",
  "sector": "Secteur informatique • ESN",
  "occupationalCategory": "Informatique",
  "jobCategory": "developpeur",
  "skills": ["SOAP", "Maven", "Intégration continue", "Anglais", "Salesforce", "Git", "Jenkins", "API REST"],
  "education": "Bac +5",
  "educationLevel": "postgraduate degree",
  "experience": "Exp. 1 à 7 ans",
  "experienceMonths": 12,
  "descriptionText": "Les missions du poste\n\nAkkodis est une société internationale de conseil en ingénierie numérique...",
  "reference": "JN -112025-69560_1793891919",
  "applyType": "UrlWithForm",
  "directApply": false,
  "companyProfile": { "name": "Akkodis", "sector": "Conseil et service informatique", "rseLabel": "EcoVadis", "headquarters": "Villeurbanne - 69", "foundedYear": 1990, "employees": "> 10 000 salariés", "openOffers": 410 },
  "companyRegistry": { "siren": "318732880", "siret": "31873288000527", "name": "AKKODIS I&S SAS (AKKODIS)", "legalForm": "SAS", "nafCode": "62.02A", "category": "GE", "staffBand": "1 000 à 1 999 salariés", "creationDate": "1980-01-01", "headOffice": { "address": "3 AVENUE DU CENTRE 78280 GUYANCOURT", "departmentCode": "78" }, "turnover": 220561146, "netResult": 5456054, "financesYear": 2025, "vatNumber": "FR06318732880", "matchConfidence": "exact name" },
  "position": 1,
  "searchQuery": "développeur",
  "searchLocation": "Nantes",
  "scrapedAt": "2026-11-06T08:14:54.204Z"
}
```

#### Fields

Fill rates are measured on 2,200 offers (two searches of 1,100: `commercial` and `technicien`, all of France) and, for the add-ons, on 200 offers in Nantes and Toulouse. A field is `null` (or `[]`) when the offer does not carry it, never a made-up zero.

| Field | Filled | What it is |
|---|---:|---|
| `jobId`, `jobUrl`, `title`, `location`, `contractType`, `workingTime`, `datePosted`, `sector`, `reference`, `tags` | 100% | Core fields |
| `company`, `companyUrl`, `companyLogo` | 99% / 90-99% | Employer (1% of offers do not name it: `anonymousCompany` true) |
| `companyType`, `isAgency` | 33-83% | HelloWork's employer-type tag: ESN, recruitment firm, temp agency (shown when the poster is not the employer itself) |
| `city`, `postalCode`, `departmentCode`, `department`, `region` | 93-99% | Place (a region-wide offer has no city) |
| `latitude`, `longitude`, `inseeCode` | 92-97% | Commune centre from the French government's commune register |
| `salary`, `salaryMin`, `salaryMax`, `salaryPeriod` | 89-98% | Posted range, or HelloWork's estimate when the employer posts none (`salaryIsEstimate` true, 15-29% of offers) |
| `salaryEstimate` | 14-27% | HelloWork's estimate distribution |
| `telework`, `teleworkLabel` | 2-45% | Only offers that state a telework policy |
| `contractDuration` | 6-42% | Fixed-term contracts, internships, missions |
| `skills` | 93-97% | Skills asked |
| `education` / `educationLevel` | 77-98% | "Bac +5" / schema.org level |
| `experience` / `experienceMonths` | 73-84% / 54-76% | "Exp. 1 à 7 ans" / minimum months |
| `qualifications` | 70-84% | Profile text |
| `descriptionText`, `descriptionHtml`, `descriptionMarkdown`, `snippet` | 99% | Full description |
| `companyDescription` | 39-62% | Employer presentation shown on the offer |
| `validThrough`, `industry`, `occupationalCategory` | 98% | schema.org data of the offer |
| `jobFunction`, `jobCategory`, `domain`, `keywords` | 94-100% | HelloWork's own classification and keyword tags |
| `superRecruiter`, `applicationTracking`, `applyType`, `directApply` | true on 9-23% / 41-79% / 100% / 76-89% | HelloWork badges and the application route |
| `benefits` | 7-15% | Items under an "avantages" heading in the description |
| `extractedUrls`, `socialProfiles` | 2-6% / 1% | Links written in the description |
| `companyProfile` | 98-99% with the add-on | The employer's HelloWork page |
| `companyRegistry` | 77-80% with the add-on | Register match (offers of agencies hiring for an unnamed client stay unmatched) |
| `isRepost`, `repostOfId` | 2-7% | Same employer + title + place under another id |
| `changeType`, `firstSeenAt`, `removedAt` | monitor mode | new / updated / unchanged / removed / details (delivered before without the job page, register match, profile or coordinates this run asks for, now with them) |

HelloWork masks e-mail addresses and phone numbers inside offers (`****@****.**`), so rows carry no contact e-mail or phone; use the company-register add-on for the employer's legal identity and head office.

### How can I use HelloWork data?

- **Recruitment and staffing sales:** list every employer hiring a role in a département this week, with its SIREN, staff band and head office.
- **Salary benchmarking:** posted ranges and HelloWork's own estimate distribution per role, city and contract.
- **Job boards and aggregators:** feed French offers with full descriptions into your site, deduplicated by `jobId`, reposts flagged.
- **Labour-market analysis:** count offers by sector, contract, telework policy or region over time.
- **HR-tech and lead lists:** filter employers by type (direct employers only, or recruitment firms) and size.

### How much does it cost to scrape HelloWork?

HelloWork Jobs Scraper is pay-per-result: **$0.72 per 1,000 offers** with the full offer page and every field in each row. No start fee. You are charged only for offers written to the dataset; skipped reposts and offers already delivered in monitor mode are not charged.

| Offers | Price |
|---:|---:|
| 100 | $0.072 |
| 1,000 | $0.72 |
| 10,000 | $7.20 |

| Add-on | Price |
|---|---|
| Company register match (`company-registry`) | $0.0045 per distinct employer matched in a run; nothing for an employer that cannot be matched with confidence |
| HelloWork company profile | free |
| Commune coordinates | free |

Apify platform usage is included in these prices. Set a **maximum cost per run** in the run options and the run stops cleanly at it, without reading offers it cannot pay for.

### Run it on a schedule: only new offers

Turn on **Monitor mode** and schedule the actor (hourly, daily) from the **Schedules** tab. The actor remembers every offer it delivered in a named key-value store (`monitorStoreName`), reads each search newest first and stops at the first page it has already seen, so a run with nothing new reads one page and charges nothing. `firstRunMode: "seedOnly"` makes the first run only remember the current offers; `monitorIncludeUpdated` also returns offers whose content changed; `emitRemovedJobs` adds a row for each remembered offer that left the search (set `maxResults` to 0 so each search is read to its end). Add a webhook, Slack, Discord, Telegram or WhatsApp destination to get the new offers as a message.

```json
{
  "searchQueries": ["comptable"],
  "location": "Bordeaux",
  "monitorMode": true,
  "monitorStoreName": "comptable-bordeaux",
  "skipReposts": true,
  "maxResults": 100,
  "slackWebhookUrl": "https://hooks.slack.com/services/..."
}
```

### Integrations, API & MCP

- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable, Notion via [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client`; code on the [API tab](https://apify.com/topapi/hellowork-jobs-scraper/api/python) and the [Apify API reference](https://docs.apify.com/api/v2).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/topapi/hellowork-jobs-scraper/api/mcp) and ask for French job offers in plain language; **Compact rows** keeps the answers small.

### More TopApi scrapers

<table>
<tr>
<td>🌴 <a href="https://apify.com/topapi/welcome-to-the-jungle-jobs-scraper">Welcome to the Jungle Jobs Scraper</a>: startup and tech jobs in France, with company profiles</td>
<td>💼 <a href="https://apify.com/topapi/indeed-jobs-scraper">Indeed Jobs Scraper</a>: jobs from Indeed's country sites, incl. France</td>
<td>🇩🇪 <a href="https://apify.com/topapi/xing-jobs-scraper">XING Jobs Scraper</a>: jobs in Germany, Austria and Switzerland</td>
</tr>
<tr>
<td>🌍 <a href="https://apify.com/topapi/naukrigulf-jobs-scraper">Naukrigulf Jobs Scraper</a>: jobs, salaries and recruiters in the Gulf</td>
<td>📍 <a href="https://apify.com/topapi/apple-maps-scraper">Apple Maps Scraper</a>: places, phones, hours and ratings for employer lists</td>
<td>🧭 <a href="https://apify.com/topapi">All TopApi actors</a></td>
</tr>
</table>

### Limits & empty runs

- **Depth:** HelloWork pages a search to its end (30 offers a page); `maxResults: 0` reads it all. Relevance order repeats some offers on deep pages (they are delivered once); for a complete read of a large search use `sortBy: "date"`.
- **Speed:** 20 offers in about 3 seconds, 100-150 in 4-14 seconds, with every offer page read, on the default 512 MB. HelloWork limits how fast one address may read (it answers HTTP 429 after roughly 900 pages read faster than about 4 a second), so the actor reads its first ~750 offers at full speed and paces itself under that limit after: 1,100 offers take about 4 minutes and 5,000 about 19 minutes (measured, with no 429 from HelloWork). If HelloWork still answers 429, the actor pauses and reads fewer pages at once instead of failing.
- **Withdrawn offers:** an offer can be withdrawn between the search and its page (about 1 in 200); it is reported in the run summary and not charged.
- **Not available:** contact e-mails and phone numbers (HelloWork masks them in offers), the employer behind an anonymous offer, and coordinates more precise than the commune.
- **Empty dataset:** no offer matches the keyword, location and filters (the status line says so), your exclusions removed every offer, or in monitor mode nothing is new. Nothing is charged for an empty run.

### FAQ

#### How many offers can HelloWork Jobs Scraper collect in one run?

As many as the searches hold: HelloWork pages a search to its end (`maxResults: 0`). In our tests one run read 5,000 offers of a 22,000-offer search (`vendeur`, newest first) with every offer page in 19 minutes. HelloWork limits how fast one address may read, so a run of several thousand offers takes several minutes; split very large reads by location or contract to keep each run short.

#### Can HelloWork Jobs Scraper filter like the HelloWork website?

Yes. Every filter of HelloWork's search form is an input (contract, telework, working time, experience, employer type, job function, sector, radius, date, salary, super recruiters), and HelloWork applies them before the pages are read, so a filtered run only reads matching offers.

#### Does HelloWork Jobs Scraper return the full job description?

Yes, from each offer's own page: text, HTML and Markdown, plus skills, education, experience, qualifications and the employer's presentation. Turn off **Full offer details** for a faster card-only list.

#### Can I run HelloWork Jobs Scraper on a schedule to get only new offers?

Yes: turn on **Monitor mode** and add a schedule. Each run returns only offers it has not delivered before; an empty run charges nothing.

#### Can HelloWork Jobs Scraper find the company behind each offer?

Turn on **Company profile** for the employer's HelloWork page and **Company register match** for its French register entry (SIREN, legal form, NAF code, staff band, directors, turnover). 77-80% of offers matched in our runs; agencies hiring for an unnamed client cannot be matched.

#### Can I use HelloWork Jobs Scraper with the Apify API or an MCP server?

Yes. Start runs and read datasets with `apify-client` for Node.js or Python, or connect an MCP client through the MCP tab. Input names of other HelloWork actors (`keywords`, `contractType`, `period`, `limit`...) are accepted.

#### Do I need a HelloWork account, cookies or an API key?

No. The actor reads what HelloWork shows to every visitor.

#### Why did my HelloWork Jobs Scraper run return no results?

The keyword, location and filters together matched nothing (the status line names the search), your exclusions removed every offer, the job ids were withdrawn, or in monitor mode nothing is new since the last run. The `RUN_SUMMARY` record gives the count for each search.

#### How is HelloWork Jobs Scraper different from other HelloWork scrapers?

It reads HelloWork's pages over plain HTTP at 512 MB (no browser), exposes every HelloWork filter including job functions, sectors and super recruiters, takes search, listing, company and job links, adds commune coordinates, HelloWork's salary estimate distribution, the company profile and the company-register match, and has a monitor mode with alerts, at $0.72 per 1,000 offers with no start fee.

#### Is it legal to scrape HelloWork?

HelloWork Jobs Scraper collects only job offers that HelloWork shows publicly; it does not log in or collect private data. Offers and the company register can name people (for example company directors), and personal data is regulated in the EU (GDPR). Make sure your use has a legitimate purpose.

#### Your feedback

We keep improving HelloWork Jobs Scraper. Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/topapi/hellowork-jobs-scraper/issues/open).

# Actor input Schema

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

Job titles or keywords, e.g. développeur, comptable, infirmier, chef de projet. Each keyword runs its own HelloWork search (with each location below). Leave empty to read only the URLs or job ids below; leave everything empty to read 100 offers from all of France.

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

A city, département or region in France (Paris, Lyon, 69, Gironde, Île-de-France), as you would type it on HelloWork. Leave empty for all of France.

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

Several locations at once: every keyword is searched in each of them (keyword x location searches). Used together with Location.

## `radiusKm` (type: `integer`):

HelloWork widens a city search to 20 km by default. Choose 0, 5, 10, 20 or 50 km; other numbers are rounded to the nearest of these.

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

HelloWork pages: a search (/fr-fr/emploi/recherche.html?k=...), a listing page (/fr-fr/emploi/metier\_...-ville\_....html), a company page (/fr-fr/entreprises/<name>-<id>.html: its active offers) or a job (/fr-fr/emplois/<id>.html). Filters below are added to pasted searches.

## `jobIds` (type: `array`):

HelloWork offer ids (the number in /fr-fr/emplois/<id>.html). Each id returns its full offer; an id whose offer was removed is reported in the run summary and not charged.

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

Offers to deliver per keyword x location search or per URL. 0 = every offer the search has (HelloWork pages a search to its end, 30 offers a page). Job ids are not capped by this.

## `maxTotalResults` (type: `integer`):

A cap on the whole run, over all searches. 0 = no run cap.

## `maxPages` (type: `integer`):

Stop a search after this many result pages (30 offers each). 0 = no page cap.

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

Only these contracts (HelloWork filters server-side). Empty = all.

## `telework` (type: `array`):

Remote-work policy of the offer. Empty = all.

## `workingTime` (type: `array`):

Full time, part time or not stated. Empty = all.

## `experience` (type: `array`):

Experience asked by the employer. Empty = all.

## `employerTypes` (type: `array`):

Who posted the offer: the employer itself, a recruitment firm, an IT services company (ESN), a temp agency or a training centre. Empty = all.

## `functions` (type: `array`):

HelloWork's job-function filter. Empty = all.

## `sectors` (type: `array`):

HelloWork's sector filter. Empty = all.

## `postedWithin` (type: `string`):

Only offers published in this window (HelloWork's own date filter).

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

HelloWork's salary filter (gross per year, rounded to 1,000, up to 100,000).

## `onlyWithSalary` (type: `boolean`):

Only offers whose salary is published (HelloWork's 'salaire renseigné' toggle).

## `superRecruiterOnly` (type: `boolean`):

Only offers from employers HelloWork marks 'super recruteur'.

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

HelloWork's order: relevance or newest first. Monitor mode always reads newest first.

## `excludeKeywords` (type: `array`):

Offers whose title contains any of these words are skipped before their page is read.

## `excludeCompanies` (type: `array`):

Offers from employers whose name contains any of these are skipped.

## `skipReposts` (type: `boolean`):

HelloWork employers re-post the same role under a new id. With this on, an offer with the same employer + title + département as one already delivered (this run, or any earlier monitor run) is skipped and not charged. Off: it is delivered with isRepost true and repostOfId.

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

Read each offer's page: full description, skills, education, experience, sector, structured salary, dates, employer type, reference and more. Off = the search card's fields only (title, employer, location, contract, salary shown, working time, telework, posted ago), faster.

## `includeDescription` (type: `boolean`):

Off = rows without descriptionText / descriptionHtml / descriptionMarkdown (smaller exports).

## `descriptionFormat` (type: `string`):

Which description fields to fill.

## `descriptionMaxLength` (type: `integer`):

Cut each description to this many characters. 0 = full.

## `includeCoordinates` (type: `boolean`):

Latitude, longitude and INSEE code of the offer's commune, from the French government's open commune register (geo.api.gouv.fr). Free.

## `includeCompanyProfile` (type: `boolean`):

Adds companyProfile from the employer's HelloWork page: sector, presentation, CSR label, founded year, revenue band, staff band, telework policy, average age and seniority, gender split, social links, recruitment steps, open offers. Free.

## `includeCompanyRegistry` (type: `boolean`):

Adds companyRegistry from the French company register (recherche-entreprises.api.gouv.fr): SIREN, SIRET, legal form, NAF code, staff band, creation date, head office, directors, turnover, net result. Charged once per employer matched; no confident match = empty, not charged.

## `compact` (type: `boolean`):

Only the core fields (id, URL, title, employer, location, contract, telework, salary, dates).

## `excludeEmptyFields` (type: `boolean`):

Remove fields that are null or empty from each row.

## `monitorMode` (type: `boolean`):

For scheduled runs: remembers every offer delivered (in a named key-value store) and returns only offers not delivered before. Reads newest first and stops at the first page that is already known, so a poll with nothing new costs almost nothing. An offer delivered earlier without the job page details, company register match, company profile or coordinates that a later run turns on comes again once with them, as changeType details (billed like any offer).

## `monitorStoreName` (type: `string`):

Name of the key-value store that holds the memory. Use one name per monitored search set.

## `firstRunMode` (type: `string`):

Deliver every current offer on the first run (emitAll), or only remember them so the next run returns new offers only (seedOnly, nothing charged).

## `monitorIncludeUpdated` (type: `boolean`):

In monitor mode, also re-read offers delivered before and deliver those whose content changed (changeType updated).

## `emitUnchanged` (type: `boolean`):

In monitor mode, deliver every offer found, marked new / updated / unchanged.

## `emitRemovedJobs` (type: `boolean`):

In monitor mode, add a row (changeType removed) for each remembered offer that is no longer in the searches. Needs every search read to its end (Max offers per search 0 or above the search total).

## `resetMonitor` (type: `boolean`):

Forget every offer remembered under this memory name and start over.

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

POST a JSON summary (count + first offers) here after each run that delivered offers.

## `webhookHeaders` (type: `object`):

Extra headers for the webhook, e.g. {"Authorization": "Bearer ..."}.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for a run alert.

## `discordWebhookUrl` (type: `string`):

Discord webhook URL for a run alert.

## `telegramToken` (type: `string`):

Your bot's token (with the chat id below).

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

The chat that receives the alert.

## `whatsappPhoneNumberId` (type: `string`):

WhatsApp Cloud API sender phone number id (with the access token and recipient below).

## `whatsappAccessToken` (type: `string`):

WhatsApp Cloud API access token.

## `whatsappTo` (type: `string`):

Recipient number in international format, e.g. 33612345678.

## `notificationLimit` (type: `integer`):

How many offers an alert lists (the count is always included).

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

HelloWork pages read at the same time.

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

Not needed: HelloWork answers direct, and the actor moves to an Apify datacenter, then a French residential proxy, by itself if a request is refused. Set your own proxy here to use it first.

## Actor input object example

```json
{
  "searchQueries": [
    "développeur"
  ],
  "location": "Paris",
  "maxResults": 20,
  "postedWithin": "all",
  "onlyWithSalary": false,
  "superRecruiterOnly": false,
  "sortBy": "relevance",
  "skipReposts": false,
  "includeDetails": true,
  "includeDescription": true,
  "descriptionFormat": "all",
  "descriptionMaxLength": 0,
  "includeCoordinates": true,
  "includeCompanyProfile": false,
  "includeCompanyRegistry": false,
  "compact": false,
  "excludeEmptyFields": false,
  "monitorMode": false,
  "monitorStoreName": "hellowork-jobs-monitor",
  "firstRunMode": "emitAll",
  "monitorIncludeUpdated": false,
  "emitUnchanged": false,
  "emitRemovedJobs": false,
  "resetMonitor": false,
  "notificationLimit": 10,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

One item per HelloWork job offer: title, employer, location, contract, telework, salary, dates, requirements, full description.

## `summary` (type: `string`):

Per-search counts (offers on HelloWork, pages, read, delivered), withdrawn offers, enrichment counts and egress.

# 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"
    ],
    "location": "Paris",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "searchQueries": ["développeur"],
    "location": "Paris",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/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 '{
  "searchQueries": [
    "développeur"
  ],
  "location": "Paris",
  "maxResults": 20
}' |
apify call topapi/hellowork-jobs-scraper --silent --output-dataset

```

## MCP server setup

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