# France Travail Jobs Scraper (`automation-lab/france-travail-jobs-scraper`) Actor

Extract public France Travail job offers by keyword, location, and contract type with companies, salaries, descriptions, and apply links.

- **URL**: https://apify.com/automation-lab/france-travail-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## France Travail Jobs Scraper

Extract public job offers from France Travail search results and detail pages.

### What does France Travail Jobs Scraper do?

France Travail Jobs Scraper collects public job listings from the official France Travail candidate website. It turns search pages into structured rows with job titles, companies, locations, contracts, salary text, descriptions, and public apply links when available.

### Who is it for?

Recruiters use it to monitor fresh French job supply.

Staffing agencies use it to map employer demand by region.

Labor-market analysts use it to track roles, contracts, and salary text.

Sales teams use it to find hiring companies in France.

### Why use it?

France Travail search pages are built for humans. This actor converts them into exportable datasets for dashboards, alerts, enrichment, and recurring market monitoring.

### Data extracted

| Field | Description |
|---|---|
| `id` | France Travail offer ID |
| `title` | Job title |
| `company` | Employer name when shown |
| `location` | City, department, or public location text |
| `contract` | Contract type |
| `workTime` | Weekly hours or full-time text |
| `salary` | Salary text when available |
| `postedDateText` | Human-readable publication text when detected |
| `description` | Detail page job description |
| `snippet` | Search result snippet |
| `url` | Job detail URL |
| `applyUrl` | Public apply/contact URL when present |
| `source` | France Travail |
| `searchUrl` | Search page that produced the row |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape France Travail jobs?

The actor uses pay-per-event pricing. You pay a small run start fee and a per-job fee for saved results. See the Apify pricing panel for the live tiered price.

### How to use it

1. Enter a keyword such as `developer`, `infirmier`, or `data analyst`.
2. Optionally set a location or department.
3. Optionally choose a contract type.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or connect it to your workflow.

### Input options

#### Keyword

Use French or English terms that France Travail search accepts.

#### Location

Use a city, region, or department-style term accepted by the public website.

#### Contract type

Supported shortcuts include CDI, CDD, temporary, seasonal, apprenticeship, freelance, and professionalization.

#### Start URLs

Advanced users can paste France Travail search result URLs directly. When start URLs are provided, they override the keyword filters.

#### Include details

Enable detail pages when you need long descriptions, salary text, work time, and apply links. Disable it for faster search-only monitoring.

### Output example

```json
{
  "id": "210FNBQ",
  "title": "Data analyst (H/F)",
  "company": "SILICEO",
  "location": "51 - ST MARTIN SUR LE PRE",
  "contract": "CDI - Temps plein",
  "salary": null,
  "url": "https://candidat.francetravail.fr/offres/recherche/detail/210FNBQ"
}
````

### Tips for best results

Use specific keywords for cleaner datasets.

Keep the first run small to confirm filters.

Use recurring runs for daily market monitoring.

Disable detail pages when you only need fresh offer IDs and URLs.

### Integrations

Send results to Google Sheets for recruiting dashboards.

Push CSV exports into BI tools for regional labor-market analysis.

Connect dataset webhooks to Slack alerts for new jobs.

Enrich employer names with CRM or lead-scoring tools.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/france-travail-jobs-scraper').call({
  keyword: 'developer',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/france-travail-jobs-scraper').call(run_input={
    'keyword': 'developer',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~france-travail-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"developer","maxItems":100}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code via the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/france-travail-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-france-travail https://mcp.apify.com/?tools=automation-lab/france-travail-jobs-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-france-travail": {
      "url": "https://mcp.apify.com/?tools=automation-lab/france-travail-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 France Travail developer jobs in Paris."
- "Find recent CDI job offers for data analysts in France."
- "Monitor France Travail nursing jobs and summarize employers by region."

### Legality

This actor extracts publicly available France Travail job-offer pages. Use the data responsibly, respect applicable laws, and avoid collecting or processing personal data unless you have a lawful basis.

### FAQ

#### Why did I get fewer jobs than requested?

France Travail may have fewer jobs for the selected filters, or duplicate offers may appear across pages.

#### Why are salary or apply fields empty?

Not every public job offer exposes salary or a direct application URL.

#### Should I enable detail pages?

Enable detail pages for richer records. Disable them for faster lightweight monitoring.

### Related scrapers

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/google-jobs-scraper

### Changelog

Initial version extracts public France Travail search results and detail-page fields.

### Notes

The actor uses HTTP extraction because public search HTML contains result rows.

No login is required.

No browser automation is required for the current public pages.

### Support

If a public France Travail page changes and output quality drops, open an Apify issue with the run URL and input used.

### Field quality

Company and location are parsed from visible result text.

Salary and long descriptions are parsed from public detail pages.

Apply links are extracted when the public detail dropdown exposes them.

### Monitoring workflow

Schedule the actor daily with the same keyword and location.

Deduplicate by `id`.

Use `scrapedAt` to separate daily snapshots.

### Recruiting workflow

Run separate tasks for each role family.

Export jobs to CSV.

Filter by contract and location.

Prioritize employers with repeated postings.

### Labor-market workflow

Run broad occupational keywords.

Group by department or city.

Track contract mix and salary text over time.

Combine with internal hiring data for supply-demand reports.

### Sales workflow

Use hiring activity as an intent signal.

Find companies hiring in your target categories.

Route new employer names to CRM enrichment.

Build alerts for strategic accounts.

# Actor input Schema

## `keyword` (type: `string`):

Job keyword or phrase to search for on France Travail.

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

Optional France Travail location/department filter, for example Paris or 75.

## `contractType` (type: `string`):

Optional contract filter code used by France Travail, such as CDI, CDD, MIS, FRA.

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

Optional France Travail search URLs. If provided, these override keyword/location filters.

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

Maximum number of job records to save.

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

Visit each public detail page to enrich descriptions, salary text, work time, and apply links.

## `includePartners` (type: `boolean`):

Include partner job offers in France Travail search results.

## Actor input object example

```json
{
  "keyword": "developer",
  "contractType": "",
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "includePartners": true
}
```

# Actor output Schema

## `overview` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "developer",
    "location": "",
    "contractType": "",
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": true,
    "includePartners": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/france-travail-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 = {
    "keyword": "developer",
    "location": "",
    "contractType": "",
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": True,
    "includePartners": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/france-travail-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 '{
  "keyword": "developer",
  "location": "",
  "contractType": "",
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "includePartners": true
}' |
apify call automation-lab/france-travail-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Travail Jobs Scraper",
        "description": "Extract public France Travail job offers by keyword, location, and contract type with companies, salaries, descriptions, and apply links.",
        "version": "0.1",
        "x-build-id": "QoYcuuL2O8AHVxhUw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~france-travail-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-france-travail-jobs-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/automation-lab~france-travail-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-france-travail-jobs-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/automation-lab~france-travail-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-france-travail-jobs-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": {
                    "keyword": {
                        "title": "🔎 Keyword",
                        "type": "string",
                        "description": "Job keyword or phrase to search for on France Travail.",
                        "default": "developer"
                    },
                    "location": {
                        "title": "📍 Location or department",
                        "type": "string",
                        "description": "Optional France Travail location/department filter, for example Paris or 75."
                    },
                    "contractType": {
                        "title": "📄 Contract type",
                        "enum": [
                            "",
                            "CDI",
                            "CDD",
                            "MIS",
                            "SAI",
                            "FRA",
                            "LIB",
                            "REP"
                        ],
                        "type": "string",
                        "description": "Optional contract filter code used by France Travail, such as CDI, CDD, MIS, FRA.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional France Travail search URLs. If provided, these override keyword/location filters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job records to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open job detail pages",
                        "type": "boolean",
                        "description": "Visit each public detail page to enrich descriptions, salary text, work time, and apply links.",
                        "default": true
                    },
                    "includePartners": {
                        "title": "Include partner offers",
                        "type": "boolean",
                        "description": "Include partner job offers in France Travail search results.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
