# APEC Jobs Scraper (`khadinakbar/apec-jobs-scraper`) Actor

Scrape APEC.fr French executive (cadre) job postings — title, company, salary, location, contract type, remote work, apply URL. HTTP-only, no login, MCP-ready.

- **URL**: https://apify.com/khadinakbar/apec-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 94.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## APEC Jobs Scraper

APEC Jobs Scraper is an Apify Actor for APEC.fr French executive (cadre) job searches. It accepts free-text keywords and structured filters for recency, salary band, contract type, remote-work policy, and experience level. Each returned record represents one APEC offer and can include the offer ID, public offer number, title, company, confidentiality flag, location, geo coordinates, salary text and parsed salary range, contract type, remote-work policy, description excerpt, published and validated timestamps, low-application flag, sector codes, and the public apply URL. Results are stored in an Apify dataset, so each output record is one job offer that you can read in Apify Console, through the Apify API, or via Apify MCP.

### Best fit and connected workflows

Use this Actor when your workflow starts with APEC.fr executive roles and you need structured offer data for search, monitoring, enrichment, or agent-assisted triage.

Good fits include:

- French job search monitoring by keyword, salary, location, contract type, or publication date.
- Executive recruiting workflows that review the public offer URL together with a concise excerpt.
- Market research on French executive hiring by remote-work policy, sector, or publication date.
- AI and automation workflows that read current APEC offers through Apify MCP.

If your next workflow step moves to another board or region, these related Actors connect cleanly to adjacent research briefs:

- Use [Ashby Jobs Scraper](https://apify.com/khadinakbar/ashby-jobs-scraper) for workflows centered on Ashby-hosted roles and that board's offer structure when the next workflow needs that Actor's focused input and output contract.
- Use [Bayt Jobs Data Scraper for MENA Listings](https://apify.com/khadinakbar/bayt-jobs-scraper) for MENA listings and Bayt-specific sourcing when the next workflow needs that Actor's focused input and output contract.
- [Built In Jobs Scraper - Hiring Intelligence Feed](https://apify.com/khadinakbar/built-in-jobs-scraper) for Built In job markets and their listing format.

### Practical scenario

Claire is a recruiter building a shortlist for French executive data roles. She starts with `data scientist`, sets `sortBy` to `date_desc`, filters to `CDI`, and limits the search to offers posted within 7 days. The returned records include the title, company, location, salary text, parsed salary bounds, remote-work policy, and public URL. Claire uses `salaryMin`, `remoteWork`, and `publishedAt` to decide which offers match her briefing, then opens the `url` field to review the public posting in a browser.

### Input

| Field | Type | Default | Notes |
|---|---|---:|---|
| `searchQuery` | string | `data scientist` | French keyword(s) searched on APEC.fr. Searches title and description. Leave empty to browse all active offers. |
| `maxResults` | integer | `50` | Maximum number of job offers to return. APEC caps a single search at about 1000 results. |
| `sortBy` | string | `date_desc` | `relevance`, `date_desc`, or `date_asc`. |
| `postedWithinDays` | integer | - | Return only offers published within the last N days. |
| `salaryMin` | integer | - | Minimum annual gross salary in EUR. |
| `salaryMax` | integer | - | Maximum annual gross salary in EUR. |
| `contractTypes` | array | - | `CDI`, `CDD`, `FREELANCE`, `STAGE`, or `ALTERNANCE`. |
| `remoteWork` | array | - | `FULL_REMOTE`, `HYBRID`, `OCCASIONAL`, or `NONE`. |
| `experienceLevel` | array | - | `JUNIOR`, `MID`, `SENIOR`, or `EXEC`. |
| `proxy` | object | `{"useApifyProxy":true}` | Apify Proxy configuration. Default datacenter proxy is sufficient for APEC public webservices. |

#### Focused input example

```json
{
  "searchQuery": "développeur python",
  "maxResults": 25,
  "sortBy": "date_desc",
  "postedWithinDays": 7,
  "salaryMin": 50000,
  "contractTypes": ["CDI"],
  "remoteWork": ["FULL_REMOTE", "HYBRID"],
  "experienceLevel": ["MID", "SENIOR"]
}
```

### Output

Results are stored in the default dataset, with one JSON record per APEC offer. The overview view highlights the fields most useful for screening: title, company, location, salary text, contract type, remote-work policy, publication date, and public URL. The output schema also exposes a run summary in key-value storage, which includes stats and a sample of the first three records.

| Field | Type | Description |
|---|---|---|
| `jobId` | string | APEC numeric offer ID. |
| `offerNumber` | string | APEC public offer number used in the public URL. |
| `title` | string | Posted job title in French. |
| `company` | string | null | Commercial name of the hiring company. |
| `isConfidential` | boolean | True when APEC hides the hiring company name. |
| `location` | string | null | Free-text French location such as `Paris 13 - 75`. |
| `latitude` | number | null | Latitude when APEC provides coordinates. |
| `longitude` | number | null | Longitude when APEC provides coordinates. |
| `salaryText` | string | null | Salary range as written by the employer in French. |
| `salaryMin` | number | null | Parsed minimum annual gross salary in EUR. |
| `salaryMax` | number | null | Parsed maximum annual gross salary in EUR. |
| `contractType` | string | null | Mapped APEC contract code. |
| `contractDurationMonths` | number | null | Duration in months for fixed-term contracts. |
| `remoteWork` | string | null | Mapped APEC remote-work code. |
| `descriptionExcerpt` | string | null | First roughly 300 characters of the listing description. |
| `publishedAt` | string | null | Publication timestamp in ISO 8601 format. |
| `validatedAt` | string | null | Validation timestamp in ISO 8601 format. |
| `lowApplicationCount` | boolean | null | APEC flag for offers with few applications so far. |
| `sectorCode` | number | null | APEC internal sector ID. |
| `sectorParentCode` | number | null | Parent sector ID. |
| `url` | string | Public APEC URL for the offer. |

#### Output example

```json
{
  "jobId": "178908136",
  "offerNumber": "178908136W",
  "title": "Data Scientist",
  "company": "Exemple Conseil",
  "isConfidential": false,
  "location": "Paris 13 - 75",
  "latitude": 48.8306,
  "longitude": 2.3551,
  "salaryText": "45 - 49 kEUR brut annuel",
  "salaryMin": 45000,
  "salaryMax": 49000,
  "contractType": "CDI",
  "contractDurationMonths": 0,
  "remoteWork": "HYBRID",
  "descriptionExcerpt": "Entreprise en forte croissance recherche un data scientist pour renforcer ses analyses et contribuer a la priorisation des sujets produit.",
  "publishedAt": "2026-06-27T08:15:00.000Z",
  "validatedAt": "2026-06-27T09:02:00.000Z",
  "lowApplicationCount": true,
  "sectorCode": 12,
  "sectorParentCode": 1,
  "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi/detail-offre/178908136W"
}
```

### How it works

This Actor uses APEC's public webservices endpoint over HTTP. It builds a search payload from your input, sends the request to APEC, paginates through the returned results, and normalizes each offer into a dataset record.

Implementation facts supplied with the Actor show:

- HTTP-only access.
- APEC public webservices endpoint usage.
- No Standby mode.
- Default memory of 512 MB.
- APEC search results include listing-level fields such as salary text, geo data, contract code, telework code, and dates.
- The public search response includes an excerpt of the job description, while the full offer text stays on the public offer page.

### Pricing

This Actor uses Pay per event plus Apify platform usage. Charged events are:

- Actor start
- Job scraped

`Job scraped` is charged for each APEC offer returned in the dataset. For example, a run that returns fifty offers charges fifty `Job scraped` events plus one `Actor start` event. Open the live Pricing tab in Apify Console to review the current event pricing and Apify platform usage details.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP for agent workflows that need structured APEC job data.

Precise tool description: query APEC.fr executive offers with keyword and filter inputs, then read the resulting dataset records for title, company, salary, location, contract type, remote-work policy, publication date, and public URL.

Exact Actor identity: `khadinakbar/apec-jobs-scraper`

> Find current APEC executive jobs for a French data team. Search for "data scientist", return the newest 20 offers, keep only CDI roles, and summarize the titles, companies, salary ranges, and public URLs.

Output interpretation:

- `jobId` and `offerNumber` identify each APEC offer.
- `salaryText` together with `salaryMin` and `salaryMax` supports compensation review.
- `remoteWork` and `contractType` group offers by policy.
- `url` points to the public APEC offer page.
- `descriptionExcerpt` provides a short triage summary from the search results.
- Results come from APEC listing data, so the dataset represents offer-level search output rather than a full detail-page crawl.
- Use `maxResults` to bound the number of returned offers.
- Use `postedWithinDays` and `sortBy` to narrow large searches.
- Cost scales with the number of returned `Job scraped` events, so recent-only searches with `date_desc` keep agent runs focused when the brief asks for fresh offers.

### Apify API example

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN || 'YOUR_APIFY_TOKEN',
});

const run = await client.actor('khadinakbar/apec-jobs-scraper').call({
    searchQuery: 'directeur financier',
    maxResults: 10,
    sortBy: 'date_desc',
    postedWithinDays: 30,
    salaryMin: 80000,
    contractTypes: ['CDI'],
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

### Best results and outcome guidance

Use a focused search query when the role family is already known, and pair it with one or two filters to keep the dataset aligned with the brief. For monitoring, `date_desc` with `postedWithinDays` keeps recent offers at the top. For compensation analysis, combine `salaryMin` and `salaryMax` with `contractTypes` so the returned offers are easier to compare. For broad discovery, leave `searchQuery` empty and use `maxResults` to control how many offers are collected in one run.

### Design note

I found that the dataset contract requires one record per offer, while the required fields are only `jobId`, `offerNumber`, `title`, and `url`. I also found that the overview view is built around `title`, `company`, `location`, `salaryText`, `contractType`, `remoteWork`, `publishedAt`, and `url`, which makes the listing data the center of this Actor.

### FAQ

#### How is this Actor different from a generic job scraper?

This Actor is scoped to APEC.fr executive offers and exposes APEC-specific fields such as `offerNumber`, `sectorCode`, `sectorParentCode`, `lowApplicationCount`, and the APEC public URL format.

#### When should I use `searchQuery` versus `postedWithinDays`?

Use `searchQuery` for role or keyword targeting, and use `postedWithinDays` when you want a recent-only slice of APEC offers. The two work well together for monitoring.

#### Can I use this Actor for salary filtering?

Yes. The input includes `salaryMin` and `salaryMax`, and the output includes both raw salary text and parsed numeric salary bounds when APEC provides them.

#### Which Actor should I use for another job board?

If your brief matches another board or region, the related Actors above point to alternatives for Ashby, Bayt, and Built In. Each one fits a different sourcing workflow.

### Responsible use

Use the data in line with APEC's terms and applicable data protection rules. The Actor works with publicly accessible APEC search data and returns listing-level information for search and analysis workflows.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword(s) searched on APEC.fr (e.g., 'développeur', 'data scientist', 'directeur financier'). Searches title and description, French syntax. Leave empty to browse all 110K+ active offers. NOT a job ID or URL.

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

Maximum number of job offers to return. Defaults to 50. APEC caps a single search at ~1000 results regardless of totalCount, so use sortBy + dateFilter to slice large queries. NOT items per page.

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

How to sort results. 'relevance' uses APEC's default scoring; 'date\_desc' returns newest first (best for monitoring); 'date\_asc' oldest first. Defaults to date\_desc.

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

Only return offers published within the last N days. Common values: 1, 7, 14, 30, 90. Leave empty for all (no date filter). Useful for daily monitoring jobs.

## `salaryMin` (type: `integer`):

Filter offers with minimum annual gross salary in euros (e.g., 50000 = 50 k€). APEC stores salary as range; filter matches offers whose lower bound >= this value. Leave empty for no filter.

## `salaryMax` (type: `integer`):

Filter offers with maximum annual gross salary in euros. Leave empty for no upper bound. Combine with salaryMin for a band (e.g., 40k–60k).

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

Filter by contract type. CDI = permanent, CDD = fixed-term, FREELANCE = freelance/contractor, STAGE = internship, ALTERNANCE = apprenticeship. Leave empty for all types.

## `remoteWork` (type: `array`):

Filter by remote-work policy. FULL\_REMOTE = 100% remote, HYBRID = partial remote, OCCASIONAL = occasional remote, NONE = on-site only. Leave empty for all.

## `experienceLevel` (type: `array`):

Filter by required experience. JUNIOR = <1 year, MID = 1–7 years, SENIOR = 7+ years, EXEC = executive. Leave empty for all levels.

## `proxy` (type: `object`):

Apify Proxy configuration. Default is auto datacenter (sufficient — APEC API has no anti-bot challenge). Override only if your account has special proxy needs.

## Actor input object example

```json
{
  "searchQuery": "développeur python",
  "maxResults": 1,
  "sortBy": "date_desc",
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

JSON dataset with all scraped APEC job offers.

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

Stats + sample of the first 3 records.

# 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 = {
    "searchQuery": "data scientist",
    "maxResults": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/apec-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 = {
    "searchQuery": "data scientist",
    "maxResults": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/apec-jobs-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 '{
  "searchQuery": "data scientist",
  "maxResults": 1
}' |
apify call khadinakbar/apec-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k3nbYDQJiLP3Fkroq/builds/8GvlPoEUzoqgwlVbW/openapi.json