# GulfTalent Job Scraper — Hiring Signals (`khadinakbar/gulftalent-job-scraper`) Actor

Search public GulfTalent jobs or scrape direct search URLs for recruiter-ready hiring records. Returns validated roles, employers, locations, salaries when disclosed, dates, descriptions, and canonical URLs from public pages only.

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

## Pricing

from $3.00 / 1,000 validated gulftalent job returneds

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

## GulfTalent Job Scraper

Search public GulfTalent pages and export recruiter-ready Gulf hiring records. It is a focused fit for staffing teams, labor-market researchers, HR-tech builders, and AI agents working with structured public job listings.

It can either build a normal GulfTalent search from one job keyword or follow public GulfTalent search URLs you have already filtered in the site. It uses GulfTalent's public structured JSON search and job endpoints, then uses a residential proxy only as an API fallback. Each persisted row is validated before it is stored and billed.

### What it extracts

| Field | Description |
| --- | --- |
| `jobId`, `title`, `jobUrl` | Stable public job identity, title, and canonical GulfTalent link. |
| `companyName`, `companyUrl` | Published employer identity and public company link where available. |
| `location`, `country` | Published city/workplace and country details. |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Disclosed compensation only. Undisclosed values remain `null`. |
| `employmentType`, `experienceText`, `industry`, `category` | Published hiring criteria and classification fields where available. |
| `description`, `requirements` | Public job-page text when detail collection is enabled. |
| `applyUrl`, `postedAt`, `postedText` | Published application path and posting-time signals where exposed. |
| `sourceUrl`, `scrapedAt` | Discovery provenance and extraction timestamp. |

It preserves the source’s published facts: undisclosed compensation remains `null`, and each row carries its public source URL and collection time.

### When to use it

Use this actor to monitor a GulfTalent role or skill, build a Gulf hiring-intelligence dataset, track competitor job openings, research publicly disclosed compensation, or export search results into a CRM, spreadsheet, ATS, dashboard, or AI workflow.

For adjacent work, use an application workflow for job submission, a candidate-data workflow for talent search, and the matching board-specific actor when another site is your source of record.

### Workflow: from search to hiring signal

A recruiting-operations team starts with a role such as `data engineer`, runs a bounded GulfTalent search, then exports the normalized dataset to its hiring dashboard. Next, it can group `companyName` and `location` to spot which employers are hiring in a market, compare disclosed `salaryText` values, or pass the public `jobUrl` records to an internal monitoring workflow. `sourceUrl` and `scrapedAt` make each downstream comparison traceable to the exact public search and collection time.

### Inputs

Use `keyword` for a standard search. The actor creates up to `maxPages` public GulfTalent search pages and stops after `maxResults` unique validated records. Use `searchUrls` when you have already selected filters in GulfTalent; those URLs override `keyword` and are handled exactly as supplied.

`includeJobDetails` defaults to `true`. It retrieves each discovered job from GulfTalent's public job endpoint for the description and any disclosed details. Turn it off for a faster, lighter search-card export. `proxyCountry` controls the residential API fallback route; it is not a job location filter.

### Quick start

Start with one role and one public Gulf market session. This collects up to ten validated records and follows their detail pages:

```json
{
  "keyword": "software engineer",
  "maxResults": 10,
  "maxPages": 1,
  "includeJobDetails": true,
  "proxyCountry": "AE"
}
```

#### Example: search a role

```json
{
  "keyword": "data engineer",
  "maxResults": 25,
  "maxPages": 2,
  "includeJobDetails": true,
  "proxyCountry": "AE"
}
```

#### Example: process a filtered GulfTalent search

```json
{
  "searchUrls": [
    "https://www.gulftalent.com/jobs/search?search_keyword=accountant"
  ],
  "maxResults": 50,
  "includeJobDetails": true,
  "proxyCountry": "SA"
}
```

### Output example

```json
{
  "jobId": "gt-123",
  "title": "Data Engineer",
  "companyName": "Example Gulf Co",
  "location": "Dubai",
  "country": "AE",
  "salaryText": "AED 12,000 - 18,000 per month",
  "salaryCurrency": "AED",
  "salaryMin": 12000,
  "salaryMax": 18000,
  "employmentType": "FULL_TIME",
  "jobUrl": "https://www.gulftalent.com/uae/jobs/data-engineer-123",
  "applyUrl": null,
  "postedAt": "2026-07-20T00:00:00.000Z",
  "sourceUrl": "https://www.gulftalent.com/jobs/search?search_keyword=data+engineer&page=1",
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

### API and agent use

Use this tool when you need public GulfTalent jobs for a role or already have a public GulfTalent search URL. It returns one dataset item per persisted job and writes `OUTPUT` plus `RUN_SUMMARY` records for machine-readable status, counts, billing, and safe diagnostics.

For a small role search, pass one `keyword` and a low `maxResults`. For a precisely filtered page you already opened in the site, pass its full URL in `searchUrls`. Treat the returned records as public market signals that complement a human recruiting workflow.

#### Run through the Apify API

After the private actor is deployed, run it with your Apify API token:

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~gulftalent-job-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"data engineer","maxResults":10,"maxPages":1,"includeJobDetails":true,"proxyCountry":"AE"}'
```

#### MCP and AI-agent prompt

> Find up to 15 public GulfTalent data-engineer jobs in the UAE and return job title, employer, disclosed salary, location, posted date, and job URL. Read `OUTPUT` and `RUN_SUMMARY`; if the outcome is `PARTIAL`, preserve the returned rows and surface the warnings instead of treating them as an empty search.

The actor is read-only with respect to GulfTalent and gathers public job-posting pages. Use the dataset for rows and the key-value records for outcome, pagination coverage, charges, and recovery guidance.

### Pricing

Pricing is Pay per event + usage:

| Charge | Price |
| --- | --- |
| Validated GulfTalent job written to the dataset | $0.003 per job |
| Actor start | $0.00005 per configured GB of memory |
| Apify compute and residential-proxy usage | Charged separately by the platform |

Only unique, fully validated records successfully written to the default dataset trigger `job-scraped`. A run with `maxResults: 20` has a maximum $0.060 in job-result event charges, plus the start event and Apify platform usage. Check the live [Pricing tab](https://apify.com/khadinakbar/gulftalent-job-scraper/pricing) for the current rate card before large scheduled runs.

For example, a bounded run that returns 10 results (10 job records) has at most $0.030 in job-result charges, plus $0.00005 for the 1-GB start event and the separately metered Apify compute/proxy usage.

### Reliability and limits

GulfTalent's rendered job pages may use Akamai protection. The actor starts with public JSON endpoints, uses bounded HTTP retries, and can confirm an unavailable route through a residential fallback. It distinguishes usable empty searches from unavailable upstream routes.

Partial useful results are preserved as `PARTIAL`. A public search that loads with no matching jobs completes as `VALID_EMPTY`. When the source route is unavailable, the actor records `UPSTREAM_FAILED` with recovery guidance. Every terminal path writes `OUTPUT` and `RUN_SUMMARY` with one of `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`.

### Freshness and provenance

Each dataset record retains the public search `sourceUrl` and its `scrapedAt` timestamp. The actor reads GulfTalent’s structured public search and job endpoints at run time, so the returned records reflect the source response received for that run. `OUTPUT` and `RUN_SUMMARY` explain the completed outcome, coverage, charges, and any recovery guidance.

### Builder's note

I designed the dependable path here to stay deliberately narrow: normalize GulfTalent’s structured public search response first, then enrich each selected job from its matching public detail response. That design makes every exported row traceable, keeps result billing tied to a validated write, and gives agents a small, predictable input-to-dataset workflow.

### Focused standalone workflow

This actor is designed as a focused standalone workflow: one public GulfTalent search or role keyword enters, and a stable, recruiter-ready job dataset exits. It is a good fit when GulfTalent is the source of record for the hiring signal; use a separate board-specific actor when another site is the source.

### Responsible use

Collect public job-posting data according to applicable law and the source platform's terms. Use the output as one transparent market-research input alongside appropriate human review and privacy-aware recruiting practices.

# Actor input Schema

## `searchUrls` (type: `array`):

Use this when you already have a public GulfTalent search page with filters set in the site. Add up to 10 https://www.gulftalent.com/jobs/... URLs. These URLs override Keyword and are not direct individual-job lookups.

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

Use this when you want the actor to build a standard public GulfTalent search. Enter one role or skill phrase, for example software engineer. This is ignored only when GulfTalent search URLs are supplied.

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

Use this when you need a predictable billable-result cap. The actor stores at most this many unique validated job records across all search pages; default 20 and maximum 200.

## `maxPages` (type: `integer`):

Use this when Keyword builds the search URLs automatically. The actor requests no more than this many public result pages; this field is ignored when GulfTalent search URLs are supplied.

## `includeJobDetails` (type: `boolean`):

Use this when you need each job's public description, disclosed salary, experience, and other page-level fields. Disable only for a faster search-card export with less complete data.

## `proxyCountry` (type: `string`):

Use this when the public GulfTalent API needs a nearby Gulf-region residential fallback route. Choose the proxy country closest to your search market; this is not a job-location filter.

## Actor input object example

```json
{
  "searchUrls": [],
  "keyword": "software engineer",
  "maxResults": 10,
  "maxPages": 1,
  "includeJobDetails": true,
  "proxyCountry": "AE"
}
```

# Actor output Schema

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

One normalized public GulfTalent job per item.

## `output` (type: `string`):

Compact machine-readable outcome with billing and warning counts.

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

Detailed search, detail-page, validation, and billing diagnostics.

# 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 = {
    "searchUrls": [],
    "keyword": "software engineer",
    "maxResults": 10,
    "maxPages": 1,
    "includeJobDetails": true,
    "proxyCountry": "AE"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/gulftalent-job-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 = {
    "searchUrls": [],
    "keyword": "software engineer",
    "maxResults": 10,
    "maxPages": 1,
    "includeJobDetails": True,
    "proxyCountry": "AE",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/gulftalent-job-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 '{
  "searchUrls": [],
  "keyword": "software engineer",
  "maxResults": 10,
  "maxPages": 1,
  "includeJobDetails": true,
  "proxyCountry": "AE"
}' |
apify call khadinakbar/gulftalent-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/WACeEQaJHjjAi4vsj/builds/3DJVa7aNF9iVSFGci/openapi.json