# Michael Page Search Scraper (`jobsapi/michaelpage-jobs-search-scraper`) Actor

Scrape job listings from MichaelPage.ae, a leading global recruitment agency specializing in professional and executive roles across the Middle East. Extract job titles, companies, locations, salary ranges, and descriptions.

- **URL**: https://apify.com/jobsapi/michaelpage-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 michael page job records

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/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

## Michael Page Jobs Search Scraper

This Apify Actor fetches public jobs from the official [MichaelPage.ae](https://www.michaelpage.ae) search and detail pages. The extraction path uses bounded native HTTPS and Cheerio; it does not use a browser, proxy, mirror, fingerprint spoofing, or access-control bypass.

### Modes

- `search` requests `https://www.michaelpage.ae/jobs`, parses official SSR job tiles, then fetches each selected `/job-detail/.../ref/...` page for detail verification.
- `single` fetches one exact official detail URL.
- `multiple` fetches several exact official detail URLs.

Every emitted row is buffered until its source identity, canonical URL, title, company, location, date, description, and detail response are verified. Incomplete rows are omitted and structured diagnostics are written to the `RUN_DIAGNOSTICS` key-value-store value.

### Input

```json
{
  "mode": "search",
  "query": "engineer",
  "location": "",
  "maxItems": 3,
  "maxCandidates": 15,
  "maxRequests": 20,
  "timeoutMs": 12000,
  "deadlineMs": 120000,
  "includeDescription": true
}
```

For `single`, provide `jobUrl`; for `multiple`, provide `jobUrls`. Compatibility aliases `url` and `urls` are also accepted. Detail URLs must be HTTPS Michael Page UAE `/job-detail/.../ref/...` pages.

`includeDescription: false` retains the required text description while omitting optional HTML, section, and bullet arrays. Each request is attempted once, detail pages are fetched sequentially, and both request count and request-work deadline are bounded. Values outside the input schema's numeric limits are clamped by the runtime.

If a direct response is HTTP 401, 403, 429, or 451, or a readable page contains a visible CAPTCHA, human-verification, security-challenge, or access-denial signal, the run stops immediately with `SKIPPED`; staged records are discarded and the status, diagnostic, and request receipts remain in the key-value store. Generic transport or other HTTP failures are `DEFERRED`, not treated as proof that Michael Page blocked access. The Actor does not retry, change identity or fingerprints, use a proxy/cookies, or try an alternate route.

### Output

Rows include source-backed identifiers and URLs, title, company, location objects, contract and industry facts, salary ranges, dates, sanitized descriptions, headings, sections, bullets, requirements, benefits, source payload provenance, canonical/detail verification flags, direct application URLs when Michael Page publishes one, request receipts, quality metrics, and field coverage.

For example, the local `AI Engineer` detail exposed the following fields (excerpt; optional salary was omitted because the source did not publish one for this job):

```json
{
  "jobId": "JN-072026-7067955",
  "title": "AI Engineer",
  "company": "Michael Page",
  "location": "International",
  "employmentType": "FULL_TIME",
  "contractType": "Permanent",
  "industry": "Technology",
  "sector": "Technology",
  "subsector": "IT Development",
  "postedDate": "2026-08-03",
  "descriptionHeadings": [
    "About Our Client",
    "Job Description",
    "The Successful Applicant",
    "What's on Offer"
  ],
  "responsibilities": [
    "Design and implement AI agent and multi-agent systems for complex business use cases.",
    "Build LLM-powered applications with advanced reasoning, planning, memory, and execution capabilities."
  ],
  "requirements": [
    "Master's or PhD in Computer Science, Data Science, Statistics, or a related discipline.",
    "Proven experience building AI agent systems and LLM-based applications beyond traditional chatbot solutions."
  ],
  "benefits": [
    "Opportunity to work on innovative AI products using the latest agent and LLM technologies.",
    "Competitive salary and benefits package with strong career development prospects."
  ],
  "applyUrl": "https://www.michaelpage.ae/job-apply/ai-engineer/ref/jn-072026-7067955",
  "jobUrl": "https://www.michaelpage.ae/job-detail/ai-engineer/ref/jn-072026-7067955",
  "detailHttpStatus": 200,
  "detailVerified": true,
  "quality": {
    "complete": true,
    "salaryPublished": false,
    "descriptionSectionCount": 4,
    "descriptionItemCount": 14
  },
  "fieldCoverage": {
    "populatedFields": 83,
    "totalFields": 83,
    "percent": 100
  }
}
```

The Actor writes run evidence to `RUN_SUMMARY`, `RUN_DIAGNOSTICS`, `RUN_REQUESTS`, `RUN_HEALTH`, and `RUN_METADATA` in the default local key-value store. Diagnostics never enter the dataset.

### Local verification

```text
npm ci --ignore-scripts --no-audit --no-fund
npm run check
npm test
npm run lint
npx --yes apify-cli validate-schema .actor/input_schema.json
```

For a local run, first confirm that the selected relative `APIFY_LOCAL_STORAGE_DIR` does not already exist and that no legacy `apify_storage` directory could be moved into it. Preserve any existing actor data, then use a new actor-relative folder with `--resurrect` (never `--purge`):

```powershell
$env:APIFY_LOCAL_STORAGE_DIR = 'storage-validation-20260925'
npx --yes apify-cli run --resurrect --input-file .\INPUT.json
npm run validate
```

The validator reads the selected `APIFY_LOCAL_STORAGE_DIR` and checks the emitted records against the summary and dataset schema.

`INPUT-dubai.json`, `INPUT-single.json`, `INPUT-multiple.json`, and `INPUT-no-description.json` provide reproducible mode checks.

### Cost and responsible use

Request, candidate, item, and wall-clock limits keep runs predictable. Begin with the small defaults; search mode uses one listing request plus one sequential detail request per candidate until `maxItems` is reached. The Actor reads public pages only. Follow Michael Page's terms and applicable privacy and data-use laws.

# Changelog

This Actor's version history is a separate document: https://apify.com/jobsapi/michaelpage-jobs-search-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Search the official listing or fetch one or many exact Michael Page detail URLs.

## `query` (type: `string`):

Job title, skill, or keyword used by search mode.

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

Optional Michael Page location, for example Dubai.

## `jobUrl` (type: `string`):

Official HTTPS /job-detail/.../ref/... URL used by single mode.

## `jobUrls` (type: `array`):

Official HTTPS detail URLs used by multiple mode.

## `url` (type: `string`):

Alias for jobUrl.

## `urls` (type: `array`):

Alias for jobUrls.

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

Maximum complete records written to the dataset.

## `maxCandidates` (type: `integer`):

Maximum listing/detail candidates considered.

## `maxRequests` (type: `integer`):

Hard upper bound on direct official HTTPS requests. Each URL is attempted at most once.

## `timeoutMs` (type: `integer`):

Maximum wait for one official request.

## `deadlineMs` (type: `integer`):

Hard wall-clock bound for the complete run.

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

Keep the required text description and omit optional HTML/section arrays when false.

## Actor input object example

```json
{
  "mode": "search",
  "query": "engineer",
  "location": "",
  "maxItems": 3,
  "maxCandidates": 15,
  "maxRequests": 20,
  "timeoutMs": 12000,
  "deadlineMs": 120000,
  "includeDescription": true
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": "engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/michaelpage-jobs-search-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 = { "query": "engineer" }

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/michaelpage-jobs-search-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 '{
  "query": "engineer"
}' |
apify call jobsapi/michaelpage-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jobsapi/michaelpage-jobs-search-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/2UVe7RAm8eegfXLiY/builds/rdz9xkaQUM167pHLn/openapi.json
