# GulfTalent Scraper: Gulf Jobs, Salaries and New Job Alerts (`datahamster/gulftalent-scraper`) Actor

GulfTalent scraper for GCC jobs (UAE, Saudi Arabia, Qatar, Kuwait, Oman, Bahrain). Many job titles and cities per run, country and category lists, salary as numbers, no start fee, no contact persons. Monitor mode returns only new jobs.

- **URL**: https://apify.com/datahamster/gulftalent-scraper.md
- **Developed by:** [Viktor Dubnytskiy](https://apify.com/datahamster) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 result items

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

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

## GulfTalent Scraper

Get jobs from GulfTalent, the GCC job board (UAE, Saudi Arabia, Qatar, Kuwait, Oman, Bahrain), as one flat row per job: title, company, city and country, posted date, Easy Apply flag. Turn on `includeDetails` for salary as numbers (min, max, currency, period), the full description, employment type, job function, company industry and the years of experience the ad asks for. No account, no start fee, no contact persons. Monitor mode turns the same input into an alert on new jobs.

**Try it:** the prefilled example (`accountant` in `Dubai`, 20 jobs) runs in 6 to 30 seconds (GulfTalent's Cloudflare challenges some requests, and the actor retries them). Results cost $1.00 per 1,000, with no per-run start fee.

**Why this one** (compared with the most-used GulfTalent actor in the Store, blackfalcondata/gulftalent-scraper, 127 users in 30 days; its input schema checked 2026-11-16):

- **No start fee.** $0.001 per job and nothing per run. The most-used actor charges $0.0007 per job plus an "Actor Start" event of $0.005 per GB of run memory on every run, so a small scheduled search costs more there: a 5-job run is $0.0085 there and $0.005 here.
- **No contact persons in the data.** Rows hold the job and the hiring company. E-mail addresses, phone numbers, WhatsApp links and recruiter names are removed from the description, and the description is cut at the ad's application block ("How to apply", "Send your CV", "Contact:"). The most-used actor's title advertises "Emails" in its output, which is personal data you then have to handle under GDPR and similar laws.
- **Hidden salaries stay hidden.** When the job page says "Salary: Not Specified", `salaryMin`/`salaryMax` are null and `salaryHidden` is true, even though GulfTalent's page code sometimes still carries an internal figure the employer chose not to show.
- **Monitor with a fixed price per check.** `mode: "monitor"` returns only jobs this monitor has not seen, $0.005 per check plus $0.001 per new job; an older job that appears again is recorded without being sold as new.
- **Many job titles and cities in one run.** Every keyword is searched in every location, each search gets a fair share of `maxItems`, and a job found twice is returned once. (The most-used actor also takes several queries and locations, as JSON arrays.)

### What you get

Real rows from the example dataset (`keywords: ["accountant"]`, `locations: ["Dubai"]`, run GR9Vddw3N5VFHUtPR, 20 jobs, 6.3 s):

| title / company | location | posted |
|---|---|---|
| Accountant / Trade License Zone | Dubai, UAE | 2026-11-05 |
| General Accountant / GG Selection | Dubai, UAE | 2026-11-05 |
| Accountant / NADIA Global | Dubai, UAE | 2026-10-16 |
| Accountant / CPG Corporation | Dubai, UAE | 2026-10-15 |
| General Accountant / RTC-1 Employment Services | Dubai, UAE | 2026-10-14 |

One row with `includeDetails: true` (run x4hOIbrxk6wdo7OWU; description shortened here):

```json
{
  "id": "570883",
  "url": "https://www.gulftalent.com/uae/jobs/general-accountant-570883",
  "scrapedAt": "2026-11-16T23:43:22.957822Z",
  "title": "General Accountant",
  "companyName": "GG Selection",
  "companyUrl": "https://www.gulftalent.com/companies/gg-selection-careers",
  "companyLogoUrl": "https://www.gulftalent.com/images1/logos/listing/RE506-8562_logo-img-gg-selection-careers-jobs.png",
  "location": "Dubai, UAE",
  "cities": [
    "Dubai"
  ],
  "country": "UAE",
  "postedAt": "2026-11-05",
  "easyApply": true,
  "employmentType": "Full Time",
  "jobFunction": "Accounting & Audit",
  "industry": "FMCG / Consumer Goods / Food & Beverages",
  "experienceMin": 5,
  "experienceMax": null,
  "salaryMin": 17000,
  "salaryMax": 20000,
  "salaryCurrency": "AED",
  "salaryPeriod": "month",
  "salaryHidden": false,
  "salaryText": "17000 - 20000 AED",
  "nationality": "Any Nationality",
  "arabicFluency": null,
  "jobLocation": "Dubai, UAE",
  "validThrough": "2027-04-04",
  "reference": "RP506-445",
  "description": "We are working with a well-established and growing FMCG business in the UAE who are looking to appoint a General Accountant to support their finance function.\nThis is a hands-on role suited to someone with solid experience across Accounts Payable, Accounts...",
  "descriptionTruncated": false,
  "detailsFetched": true,
  "query": "accountant",
  "searchLocation": "Dubai",
  "searchCategory": null,
  "rank": 2
}
```

`postedAt` is the date GulfTalent shows on the list (day and month; the year is the latest one that is not in the future) or, with `includeDetails`, the job page's date. `salaryMin`/`salaryMax` are in `salaryCurrency` per `salaryPeriod` as the employer wrote them; null when hidden (`salaryHidden: true`). `experienceMin`/`experienceMax` are read from the ad's text ("8 years of experience", "3-5 years"), null when it does not say. `cities` and `country` are split from the list's location text.

### Use cases

- Get a morning alert with only the new GulfTalent jobs for your role in Dubai, Riyadh or Doha.
- Compare advertised salaries for a role across GCC countries.
- Track which companies and recruiters hire for a role.
- Feed a job board, newsletter or spreadsheet with fresh Gulf jobs.

### Try it

```json
{"keywords": ["accountant", "auditor"], "locations": ["Dubai", "Riyadh"], "postedWithin": "7d", "includeDetails": true, "maxItems": 100}
```

```json
{"categories": ["software"], "countries": ["UAE", "Qatar"], "maxItems": 200}
```

Monitor (save as a task and schedule it daily or hourly):

```json
{"mode": "monitor", "keywords": ["accountant"], "locations": ["Dubai"], "maxItems": 50}
```

### Input

- `keywords`: job titles. Each is read as GulfTalent's job-title page, for example `/uae/jobs/dubai/title/accountant`, which the site matches against job titles (not the full ad text).
- `locations`: GCC cities or countries. Every keyword is searched in every location.
- `countries`: used when `locations` is empty.
- `categories`: GulfTalent's 32 job categories, without keywords, per country.
- `postedWithin`: last day, 3, 7, 14 or 30 days.
- `includeDetails`: job page fields, including salary numbers. One extra request per job.
- `maxResultsPerSearch`: depth of each search, 25 jobs per page.
- `mode: "monitor"`, `monitorStateId`, `webhookUrl`, `telegramBotToken` / `telegramChatId`: see Monitor mode.

### Monitor mode

Run the same input as a scheduled task with `mode: "monitor"`. The first run of each search is a baseline: it records the first 100 jobs (or `maxResultsPerSearch`), reads no job pages and charges only the check. Later runs return only jobs the monitor has not seen whose posted day is at most 2 days before the newest day of the last run; an unseen job posted earlier than that is recorded without being returned. GulfTalent ranks title pages itself (old and new jobs mixed on every page), so each check reads the whole depth of each search. A title search with up to 300 jobs is read whole on every check (when `maxResultsPerSearch` is empty); a bigger one is read to `maxResultsPerSearch` (100 by default), and a new job ranked below that depth is missed. Set `maxResultsPerSearch` to at least the search's job count, or narrow the search by city. A job returned without its details (job page refused) is completed on a later run at no charge. Measured: a baseline of 100 accountant jobs in the UAE with `includeDetails` on read 4 pages and no job page, $0.0021 usage (run gnVB3qEM0ftvMcdGd); the next check read the same 4 pages, 0 new, $0.0022 usage (u7qhatyoIghnchV0D).

### Pricing

Pay per event, platform usage paid by you:

- `result`: $0.001 per job (scrape mode).
- `monitor-check`: $0.005 per monitor run.
- `change`: $0.001 per new job in monitor mode.

Platform usage (compute and residential proxy traffic, paid by you), measured on our runs (512 MB is the default run memory; our runs used 256 MB, so compute at the default is about double the compute part): the 20-job example $0.0006 (6 s); 60 jobs from the Qatar and Kuwait lists $0.0017 (about $0.03 per 1,000 jobs on top of the result price); with `includeDetails` about $0.19 to $0.46 per 1,000 jobs on top of the result price (measured on 40- to 60-job runs, mostly residential proxy traffic for the job pages, 80-140 s); a monitor check of one 100-job search about $0.002 whether or not anything is new. About 1 in 5 GulfTalent requests through the proxy gets a Cloudflare challenge; the actor retries those on a new exit, and the retries are part of the usage.

Store discounts: SILVER 10% off, GOLD and above 20% off. If you find a problem, please open an issue; if it works for you, a review helps.

### Related actors

- [Naukrigulf Scraper](https://apify.com/datahamster/naukrigulf-scraper)
- [Bayt Jobs Scraper](https://apify.com/datahamster/bayt-jobs)
- [LinkedIn Jobs Scraper](https://apify.com/datahamster/linkedin-jobs-scraper)
- [Career Site Jobs Monitor](https://apify.com/datahamster/ats-jobs)

### Limits

- GulfTalent's keyword search page is disallowed for robots (`/jobs/search` in robots.txt), so this actor does not use it. A keyword is read as the site's job-title page: "accountant" finds "Senior Accountant" and "Accountant General", but not an ad that mentions accounting only in its text. A keyword with no title page returns nothing and is named in the status (`noTitlePage`).
- GulfTalent has no page that combines a category with a city or a job title, so `categories` work only without keywords and locations.
- Monitor on a title search with more than 300 jobs: GulfTalent ranks title pages itself, so a new job can land below the depth the monitor reads (`maxResultsPerSearch`, 100 by default) and is then missed. Use a city or a higher `maxResultsPerSearch` for broad titles. Country, city and category lists are newest first and do not have this problem within the depth.
- Cities: the main GCC cities are built in. Another city is tried under the single country you pick in `countries`; a place GulfTalent has no page for returns nothing and is named in the log, the status and `GULFTALENT_STATS.unknownLocations`.
- Salary, description, employment type and experience come only from job pages (`includeDetails`). Most employers hide the salary: 7 of 40 accountant and civil engineer jobs in Dubai and Riyadh had salary numbers in our run (x4hOIbrxk6wdo7OWU). `experienceMin` was found in the text of 21 of those 40 ads.
- GulfTalent shows its pages to the Apify residential proxy only (datacenter and direct requests get a Cloudflare challenge), so every page goes through residential proxy traffic, which is part of the platform usage you pay.
- If GulfTalent changes its pages or refuses the proxy, a run ends with `emptyReason: blocked` or `source_changed`, not with an empty success.

### FAQ

**Do I need a GulfTalent account?** No. The actor reads public job pages.

**Can I get the recruiter's name, e-mail or phone?** No. Rows hold the job and the hiring company, not people.

**Which currencies?** The one the employer used: AED, SAR, QAR, KWD, OMR, BHD, USD and others.

### Changelog

- 0.1 (2026-11-17): first version.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, one per line, e.g. "accountant", "civil engineer", "nurse". Each one is read as GulfTalent's job-title page (the site matches it against job titles, not full text) in every location below. Leave empty to list all jobs by location, country or category.

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

GCC cities or countries, one per line, e.g. "Dubai", "Abu Dhabi", "Riyadh", "Doha", "Saudi Arabia". Every keyword is searched in every location. Built in: the main cities of the UAE, Saudi Arabia, Qatar, Kuwait, Oman and Bahrain ("Makkah", "Madinah", "RAK", "KSA" understood). Another city is tried under the one country picked in Countries; a place GulfTalent has no page for returns nothing and is named in the log and status. Leave empty to use Countries.

## `countries` (type: `array`):

GCC countries to search when Locations is empty, e.g. \["UAE", "Qatar"]. Empty with keywords = all countries GulfTalent lists; empty without keywords = all six GCC countries.

## `categories` (type: `array`):

GulfTalent job categories, e.g. \["accounting", "software"]. Used without keywords, per country in Countries (or all countries). GulfTalent has no category page per city or per job title, so categories cannot be combined with keywords or locations.

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

Keep only jobs posted in this window, by the posted date the list shows. Example: 7d.

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

Read each job's page too: salary as numbers (min, max, currency, period; null when the employer hides it), full description, employment type, job function, company industry, years of experience read from the ad, nationality, reference, closing date. One extra request per job.

## `maxResultsPerSearch` (type: `integer`):

How deep each search reads (25 jobs per page). Empty = 500 in scrape mode, 100 in monitor mode.

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

Stop after this many results (you are charged only for pushed items)

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

scrape = full results; monitor = only new/changed items since the previous run of this task

## `monitorStateId` (type: `string`):

Optional state id when not running as a saved task (monitor mode)

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

POST a change summary here in monitor mode

## `telegramBotToken` (type: `string`):

Optional: bot token for monitor-mode change summaries

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

Optional: chat id that receives monitor-mode summaries

## Actor input object example

```json
{
  "keywords": [
    "accountant"
  ],
  "locations": [
    "Dubai"
  ],
  "postedWithin": "any",
  "includeDetails": false,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

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

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

## `runSummary` (type: `string`):

RUN_SUMMARY record

# 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 = {
    "keywords": [
        "accountant"
    ],
    "locations": [
        "Dubai"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/gulftalent-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 = {
    "keywords": ["accountant"],
    "locations": ["Dubai"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datahamster/gulftalent-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 '{
  "keywords": [
    "accountant"
  ],
  "locations": [
    "Dubai"
  ],
  "maxItems": 20
}' |
apify call datahamster/gulftalent-scraper --silent --output-dataset

```

## MCP server setup

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