Rejoignez un acteur majeur…
", "candidateProfile": "Indispensables :\n- Plus de 6 ans d'expérience directe en Gouvernance Data…", "companyDescription": "DGTL / Signe + est le facilitateur pour tous les acteurs qui recherchent des ressources ou des missions DATA…", "skills": [ { "label": "Gouvernance des données", "type": "SAVOIR_FAIRE", "level": "Confirmé" }, { "label": "Anglais", "type": "LANGUE", "level": "Courant" } ], "applyUrl": "https://www.jobposting.pro/emploi-2665246-113#postuler", "applicationMethod": "URL_ONLY", "firstPublishedAt": "2026-08-06T17:02:38.000Z", "isRepost": true, "updatedAt": "2026-09-10T03:38:05.000Z", "experienceLevelId": 597155, "experienceLevel": "Minimum 5 ans", "jobFunctionId": 101813, "jobFunction": "Système, réseaux, données", "jobFunctionFamily": "Informatique", "jobRoleId": 600070, "jobRole": "Chief Data Officer", "positionTypeId": 101900, "positionType": "Cadre du secteur privé", "travelZoneId": 596720, "travelZone": "Pas de déplacement", "numberOfPositions": 1, "isPartTime": false, "jobReference": "2665246", "companyLegalName": "DGTL PERFORMANCE", "companyId": 803909, "detailFetched": true, "searchKeyword": "data", "searchUrl": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&typesConvention=143685&sortsType=DATE&sortsDirection=DESCENDING", "scrapedAt": "2026-09-17T08:10:00.000Z" } ``` You can download the dataset in various formats such as JSON, HTML, CSV or Excel. #### All 77 fields | Fields | What you get | | --- | --- | | `id`, `offerNumber`, `url`, `source`, `title` | `179239722`, `179239722W`, `https://www.apec.fr/candidat/recherche-emploi.html/emploi/detail-offre/179239722W`, `apec.fr`, `Data Manager Gouvernance Data F/H` | | `company`, `isConfidential`, `logoUrl`, `employerType` | `DGTL Performance`, `false`, logo URL, `Cabinet de recrutement` (with **Tag each offer with its employer type**) | | `postingOrigin`, `isAggregatorListing` | `ADEP` (APEC recruiter back-office), `SITE_WEB_APEC`, `IMPORT_XML`, `AGREGATION` = resold by another job board → `true` | | `locationText`, `city`, `departmentCode`, `department`, `region`, `country`, `latitude`, `longitude`, `distanceKm` | `Paris 01 - 75`, `Paris 01`, `75`, `Paris`, `Ile-de-France`, `France`, `48.86`, `2.34`, `7.4` (radius searches) | | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryBasis`, `salaryIsNegotiable` | `45 - 50 k€ brut annuel`, `45000`, `50000`, `EUR`, `YEAR`, `GROSS`, `false` (`true` for "A négocier") | | `contractType`, `contractDurationMonths`, `remoteWork` | `CDI`, `null`, `Partiel possible` | | `sector`, `nafCode`, `nafLabel` | `Conseil et gestion des entreprises`, `7022Z`, `CONSEIL POUR LES AFFAIRES…` | | `publishedAt`, `firstPublishedAt`, `isRepost`, `validatedAt`, `updatedAt` | ISO 8601 — date shown by apec.fr, **first publication (the real age)**, `true` when the offer was pushed back to the top, validation, last edit | | `descriptionSnippet` | the 283-character teaser shown in search results | | `description`, `descriptionHtml`, `candidateProfile`, `companyDescription` | the full advert in three parts (plain text), and its HTML as apec.fr stores it — not sanitized: clean it before inserting it into a web page | | `skills` | `[{ "label": "Python", "type": "SAVOIR_FAIRE", "level": "Confirmé" }, …]` (know-how, soft skills, languages) | | `applyUrl`, `applicationMethod` | external application link, `URL_ONLY` / `EMAIL_URL` | | `experienceLevel`, `jobFunction`, `jobFunctionFamily`, `jobRole`, `positionType`, `travelZone`, `numberOfPositions`, `isPartTime`, `jobReference` | `Minimum 5 ans`, `Système, réseaux, données`, `Informatique`, `Chief Data Officer`, `Cadre du secteur privé`, `Nationale`, `1`, `false`, `2665246` | | `lowApplicantCount`, `isDirectClient`, `isQualityChecked`, `relevanceScore` | APEC's own flags and search score | | `searchKeyword`, `searchUrl`, `scrapedAt` | which search found the offer, the equivalent apec.fr page, ISO timestamp | | `companyId`, `companyLegalName`, `isGeolocated`, `detailFetched` | APEC's own company id and registered name, whether APEC placed the offer on a map, and whether the full advert could be read | | `employerTypeId`, `contractTypeId`, `remoteWorkId`, `sectorId`, `nafCodeId`, `postingOriginCode`, `experienceLevelId`, `jobFunctionId`, `jobRoleId`, `positionTypeId`, `travelZoneId` | the raw APEC id of each decoded label, side by side with it: join on stable codes | ### 💡 Tips #### How to get more results Leave `maxItems` at `0` and keep the search broad (no keywords, a whole region rather than a single city) — APEC exposes every matching offer, there is no result cap. Add `employerTypes` only when you want to narrow the board (e.g. direct employers). #### How to reduce costs The price is per offer saved: `maxItems`, `maxItemsPerQuery`, **Only new offers** and the filters on the offers are the levers (nothing filtered out is charged). Filters of the site (contract, place, salary…) are cheaper still: the offers are never downloaded. Turning `includeDetails` off makes runs faster but does not change the price. #### Several searches in one run `searchQueries` × `locations` = one search each (4 above), max 500 per run. **Max offers per search** caps each of them, so that the first one does not use the whole **Max offers** budget; an offer found by two searches is saved once and counts for the first. #### Monitoring: only the new offers Tick **Only new offers** (`onlyNew`), give each schedule its own **Memory key** (`stateKey`) and schedule the Actor daily. The first run returns everything; the next ones return only the offers no previous run with the same **Memory key** delivered, down to the oldest one the last run delivered for each search — the others are skipped before their details are opened and are **not charged**. The memory lives in the named key-value store `apec-jobs-scraper-seen` of your account (up to 150 000 offers per key). Give each schedule its own key; **Reset the memory** starts over. A re-posted offer keeps its number: it is not delivered twice. Keep the date sort, and add **Skip re-posted offers** if a re-post should not count as new. A run that finds nothing new ends green with "No new or matching offers" after a few search pages. #### Filter by publication date `postedAfter` / `postedBefore` take a date (`2026-09-01`, the whole day in Paris time) or a period before now (`7 days`, `2 weeks`, `1 month`: same time of day in Paris; `24 hours` through the API). The date is `publishedAt`, the one apec.fr shows and sorts by: a re-post moves it to the day the offer came back to the top, so add **Skip re-posted offers** for truly new offers. With the default date sort, the crawl stops at the first page older than `postedAfter`. #### Radius search `"locations": ["Villeurbanne"], "radiusKm": 15` = offers within 15 km of Villeurbanne, like "à moins de 15 km" on apec.fr (the site adds the offers of the city itself). Or `"radiusKm": 20, "latitude": 45.764, "longitude": 4.8357` around any point. Departments, regions and countries cannot be the centre of a radius. #### Start URLs Paste apec.fr search URLs (`https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75&typesContrat=101888`): their filters are kept (keywords, places, contract type and duration, experience, education level, internship length, start date, job function, sector, employer type, position status, remote work, business travel, geolocated only, salary bounds or band, posting age, sort, and a `distance` around one city) and the other input filters fill what the URL does not set. Single offer URLs (`…/detail-offre/179239722W`) are scraped directly. The `page` of a pasted search URL is not read: the search starts at its first page, and the same search pasted twice (another page, a tracking key) is one search. An offer URL pasted alone has no search-result card: `validatedAt`, `descriptionSnippet` and `isDirectClient` are `null`, every other field is the same as when a search finds it. ### 🔌 Integrations and API Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON, CSV or Excel from any tool, with only the fields you need (`fields`, `omit` options of the dataset export). Tick **Drop empty fields** (`excludeEmptyFields`) for a compact JSON without null or empty values — the export's `skipEmpty` drops empty offers, not empty fields. ### ❓ FAQ #### Is it legal to scrape apec.fr? The Actor only reads what apec.fr shows publicly to any anonymous visitor: job advertisements. It logs in to nothing and solves no captcha. Job adverts can contain personal data (a named contact in the text), which is protected by GDPR: do not store it without a legitimate reason — recruiter names and e-mails are never output. You are responsible for using the data in compliance with apec.fr's Terms of Use and applicable law. This Actor is not affiliated with, endorsed by or connected to the APEC. #### Does it need a login or a proxy? No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). Your own proxies, if you give some, serve the search pages: the offer pages always go through the included proxy. A request apec.fr turns away is retried at once on a new proxy session (without a proxy, after a pause of 5 seconds, doubled at each retry up to 300 seconds). #### Is the data safe to open in Excel or to show on a web page? Titles and advert texts are the recruiters' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@` (a title such as `-20% de turnover`, a reference such as `=REF2026`): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value. **For Excel, download the Excel (XLSX) export**: its cells are written as text, so a leading `-` or `=` is shown as written (measured: `=1+1` stays `=1+1`); the CSV export is raw, so if you open a CSV, import these columns as text. `descriptionHtml` is the advert's HTML exactly as apec.fr stores it, and the Actor does not sanitize it: escape it, or clean it with a sanitizer, before putting it on a web page — as you would with any text written by a stranger. #### Good to know - About **40 % of the board are "Partenaire" offers** (`postingOrigin: AGREGATION`, `isAggregatorListing: true`): adverts resold by other job boards (cadremploi, Meteojob, Direct Emploi…), where `company` is often the board's name. Use `employerTypes`, `postingOrigins` or `excludeCompanies` to keep them out. - `employerType` is filled when the search is restricted to one type: **Tag each offer with its employer type** runs each search once per type (apec.fr has no such field per offer; the 5 types split the board exactly), a few more search pages, and **Max offers per search** then applies to each type. - A radius around a city needs its coordinates: apec.fr's own place autocomplete gives them (1 light request per city; Paris, Lyon and Marseille are built in). A city apec.fr cannot place fails that search with a clear message — use `latitude` / `longitude` then. - `salaryMin` / `salaryMax` filters are APEC's own: an offer is kept when its published range overlaps yours; offers without a figure ("A négocier") are always kept — add **Only offers with a salary figure** to drop them. - APEC re-publishes offers regularly: `publishedAt` moves, `firstPublishedAt` does not, `isRepost` tells them apart (`null` without details). - **Only new offers**: a date-sorted search is read down to the oldest offer the last run delivered for it (same memory key), no further — an older offer never comes: one that run left out (its cap), or one apec.fr publishes late under an older date. **Reset the memory**, or a new key, reads deeper. The search also stops after 500 already-delivered offers in a row, or at the run's cap (`maxItems` / `maxItemsPerQuery`) of them: a previous run under the same cap never delivered more in a row. A delivered offer re-posted since the previous run (back on top with a newer date) does not count and lowers that cap by one. Two runs at the same time on the same memory key may deliver an offer twice. - Date-sorted crawls of thousands of offers can see a few offers twice (new offers are inserted at the top while the crawl runs): they are deduplicated on `offerNumber`. `sortBy: "ID"` is steadier for very deep crawls. - Recruiter names and e-mails are **never** output: only what the public offer page shows. - An offer URL pasted next to a search that also finds it is saved once, counted in that search. - If a detail cannot be fetched after every retry (a rare refusal, a network error), the offer is still saved from its search-result card with `detailFetched: false`, and its URL is listed in the `FAILED_REQUESTS` record of the key-value store. A run that saves nothing while requests failed ends as **failed**, never as an empty success. If apec.fr refuses the full adverts one after the other (20 in a row — or **Max offers** when it is lower, 8 at least —, more refused than read), the run stops and fails instead of charging rows without their details. **A run the platform stops without warning** (out of memory, run timeout) - Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the offers already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them. - With **Only new offers**, the memory is saved once a minute: resurrect the stopped run and the offers it had saved meanwhile join the memory; leave it stopped for good, and the next run may return up to a minute of them once more. #### Something doesn't work? The last line of the log counts the offers saved, filtered out, already delivered and no longer on apec.fr (an offer URL pasted alone that was removed), and the requests that failed after every retry. Those requests and the removed offers are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store (a search page under its apec.fr URL). A run that saved nothing and had failed requests fails, and its last message gives the cause (a search apec.fr rejects says so, instead of "run it again"). A run that saved some offers fails too when at least as many requests failed for good as were read (page 1 read, the next pages or the offer pages blocked): a green run with a short dataset would hide the outage. One failed request among many is only a warning. If apec.fr changes its pages, you are told instead of paying for blank rows. A search page that counts offers but gives none the Actor can read is an error (listed in `FAILED_REQUESTS`), never a quiet "No offers found". If the first 20 offers read all lack their title, publication date, salary text, contract type, posting origin, company (confidential offers aside), place, sector or — with `includeDetails` — description or first publication date, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first offers are charged. An offer that `postedAfter` / `postedBefore` drops because it has no date at all counts among those 20. ### 🛟 Support Open an issue in the **Issues** tab with a link to your run: the log and the `FAILED_REQUESTS` record of the key-value store show which requests failed and why. # Actor input Schema ## `startUrls` (type: `array`): apec.fr search URLs (`https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75`, pagination is automatic) or single offer URLs (`https://www.apec.fr/candidat/recherche-emploi.html/emploi/detail-offre/179239722W`). Max 1 000 URLs. The site's filters in the URL are kept: keywords, places, contract type and duration, experience, education level, internship length, start date, job function, sector, employer type, position status, remote work, business travel, geolocated only, salary (bounds or band), publication date, sort, and a `distance` around ONE city (like the site, the radius is ignored with several places). When not empty, **Keywords**, **Locations** and the radius fields are ignored; the other filters below fill what a URL does not set. ## `searchQueries` (type: `array`): Free-text searches, one search per entry (`data engineer`, `chef de projet`, `comptable`), times each location below (max 500 searches per run). Offers found by several searches are saved once. Leave empty to crawl the whole board (≈ 100 000 live offers, newest first). ## `locations` (type: `array`): Places, resolved against APEC's own list: a department number or name (`75`, `Rhône`), a region (`Ile-de-France`, `Bretagne`), a city (`Lyon`, `Toulouse`, `Paris 15`), `France`, or a country (`Allemagne`). One search per place, so that **Max offers per search** applies to each. Empty = everywhere (France + international). ## `maxItems` (type: `integer`): Maximum number of offers to save (after deduplication across searches). 0 = no limit. For reference: `data` ≈ 8 000 offers, `commercial` ≈ 28 000, whole board ≈ 100 000. ## `maxItemsPerQuery` (type: `integer`): Cap for EACH search (keyword × location, × employer type when tagged, or search URL), so that the first search cannot use up the whole **Max offers** budget. 0 = no per-search cap. ## `contractTypes` (type: `array`): Empty = all contract types. ## `postedWithin` (type: `string`): Only offers published (or re-published) in the last N days. `1` + a daily schedule = monitoring of new offers. ## `sortBy` (type: `string`): Order of results. New offers are inserted at the top of a date-sorted crawl while it runs (duplicates are removed); `ID` is steadier for crawls of thousands of offers. ## `includeDetails` (type: `boolean`): Open each offer (1 extra request per offer) for the full advert text (description, candidate profile, company presentation), skills, apply link, experience level, job function, first publication date and number of positions. Off = search-result fields only (the description is then a 283-character snippet): one request per 100 offers instead of one per offer, so 1 000 offers take seconds instead of minutes. ## `experienceLevels` (type: `array`): Experience required by the offer. ## `remoteWork` (type: `array`): Remote-work policy stated in the offer. ## `employerTypes` (type: `array`): Who posts the offer. `Partenaire` offers come from other job boards: the company name is then the board's (e.g. cadremploi), not the employer's. ## `tagEmployerType` (type: `boolean`): Fills `employerType` on every offer (Entreprise, Cabinet de recrutement, Agence d'emploi, SSII / ESN, Partenaire). apec.fr gives no such field per offer, so each search is run once per employer type (the 5 types split the board exactly): a few more search pages, and **Max offers per search** applies to each type. Off: `employerType` is filled only when **Employer types** holds a single type. ## `sectors` (type: `array`): Industry sector of the employer (APEC's 29 sectors). ## `jobFunctions` (type: `array`): Job family (10) or sub-function (46), APEC's own classification. ## `jobRoles` (type: `array`): APEC's 502 métiers, by name (`Data engineer`, `Contrôleur de gestion`, case and accents ignored) or id. Narrower than **Job functions**; offers of any selected function OR role are kept. Each offer's métier is in `jobRole` (with details). ## `positionStatus` (type: `array`): Status of the position. ## `salaryMin` (type: `integer`): Gross annual salary floor in thousands of euros, e.g. `45`. APEC keeps every offer whose published range overlaps \[min, max]; offers with 'A négocier' (no figure) are kept too. ## `salaryMax` (type: `integer`): Gross annual salary ceiling in thousands of euros, e.g. `70`. ## `contractDurationBand` (type: `string`): Length of fixed-term contracts (CDD, interim…). One band only: apec.fr accepts a single value. ## `educationLevel` (type: `string`): Degree asked for. apec.fr fills it on internships and work-study offers (half of the internships), rarely elsewhere. ## `internshipDuration` (type: `string`): Internships only (combine with contract type `Stage`). ## `startDateWithin` (type: `string`): When the job starts. ## `travelZones` (type: `array`): Travel the job requires (`travelZone` in the output, with details). ## `onlyGeolocated` (type: `boolean`): Keep only the offers apec.fr can place on a map (`isGeolocated`, `latitude`, `longitude` filled: ≈ 97 % of the board). ## `radiusKm` (type: `integer`): 0 = off. With cities in **Locations**: a radius around each city (apec.fr adds the offers of the city itself; departments, regions and countries are refused). With **Latitude** / **Longitude**: around that point, **Locations** left empty. Each offer gets `distanceKm`. ## `latitude` (type: `number`): Centre of the radius, e.g. `45.764` (Lyon). Set together with **Longitude** and **Radius (km)**. ## `longitude` (type: `number`): Centre of the radius, e.g. `4.8357` (Lyon). ## `postedAfter` (type: `string`): Only offers whose publication date (`publishedAt`: the date apec.fr shows, which a re-post moves to the day the offer came back to the top) is on or after this date: `2026-09-01`, or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too). With the date sort, the crawl stops at the first page older than that. Add **Skip re-posted offers** for truly new offers. ## `postedBefore` (type: `string`): Only offers published on or before this date (the whole day is included), or older than a period such as `30 days`. ## `excludeKeywords` (type: `array`): Drop the offers whose title contains one of these words (case and accents ignored), e.g. `stage`, `alternance`, `senior`. ## `companyNameContains` (type: `array`): Keep only the offers whose company name contains one of these texts (case and accents ignored). Confidential offers have no company name and are dropped. ## `excludeCompanies` (type: `array`): Drop the offers whose company name contains one of these texts, e.g. `cadremploi`, `Meteojob` (job boards reselling offers). ## `excludeConfidential` (type: `boolean`): Drop the offers whose employer is hidden (`isConfidential`). ## `onlyLowApplicantCount` (type: `boolean`): Keep only the offers apec.fr flags as having received few applications (`lowApplicantCount`). ## `requireSalary` (type: `boolean`): Drop the 'A négocier' offers: keep only those with an amount (`salaryMin` or `salaryMax`), about 2 offers in 3. ## `postingOrigins` (type: `array`): How the offer reached apec.fr (`postingOrigin`). Empty = all. Leave `AGREGATION` out to skip the offers resold by other job boards (≈ 40 % of the board). ## `skipReposts` (type: `boolean`): Drop the offers whose first publication is older than the date apec.fr shows (`isRepost`): offers pushed back to the top, often weeks old (16 of the 30 newest offers of the board on 2026-09-17). Needs **Include details** (the first publication date comes with the details); a dropped offer is not charged. ## `onlyNew` (type: `boolean`): Skip the offers that a previous run (same **Memory key**) already delivered, re-posted ones included: they are not saved and not charged, and their details are not even opened. A date-sorted search is read down to the oldest offer the last run delivered for it, no further — an older offer never comes: one that run left out (its cap), or one apec.fr publishes late under an older date; **Reset the memory** reads deeper. First run = everything is new. ## `stateKey` (type: `string`): Name of the memory used by **Only new offers**. Give each schedule / task its own key (e.g. `data-lyon`) so that they do not share their memory. Letters, digits, `-` and `_`. ## `resetState` (type: `boolean`): Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every offer again. Untick it afterwards. ## `excludeEmptyFields` (type: `boolean`): Remove null values, empty texts and empty lists from every offer: a compact JSON, smaller exports (e.g. the 26 detail fields of a run without **Include details**). Off: every offer has all the fields (stable CSV columns). The dataset export cannot do this: its `skipEmpty` / `clean` options drop empty offers, not empty fields. ## `proxyConfiguration` (type: `object`): Apify Proxy or your own proxies, for the search pages: the offer pages always go through the proxy included in the price, whatever you set here. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor. ## `maxConcurrency` (type: `integer`): Maximum number of requests processed in parallel. Keep 1: the pace is set by "Max requests per minute". ## `maxRequestsPerMinute` (type: `integer`): Global request rate (search pages + offer details). Lower it if the log shows HTTP 429 / 403. ## `maxRequestRetries` (type: `integer`): Retries per request before it is marked as failed. ## `debugLog` (type: `boolean`): Include debug messages in the run log. ## Actor input object example ```json { "searchQueries": [ "data engineer" ], "locations": [], "maxItems": 100, "maxItemsPerQuery": 0, "contractTypes": [], "postedWithin": "ANY", "sortBy": "DATE", "includeDetails": true, "experienceLevels": [], "remoteWork": [], "employerTypes": [], "tagEmployerType": false, "sectors": [], "jobFunctions": [], "jobRoles": [], "positionStatus": [], "contractDurationBand": "ANY", "educationLevel": "ANY", "internshipDuration": "ANY", "startDateWithin": "ANY", "travelZones": [], "onlyGeolocated": false, "radiusKm": 0, "excludeKeywords": [], "companyNameContains": [], "excludeCompanies": [], "excludeConfidential": false, "onlyLowApplicantCount": false, "requireSalary": false, "postingOrigins": [], "skipReposts": false, "onlyNew": false, "stateKey": "default", "resetState": false, "excludeEmptyFields": false, "proxyConfiguration": { "useApifyProxy": true }, "maxConcurrency": 1, "maxRequestsPerMinute": 120, "maxRequestRetries": 5, "debugLog": false } ``` # Actor output Schema ## `results` (type: `string`): No description # 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 '