# Naukrigulf Jobs Scraper (`epicscrapers/naukrigulf-jobs-scraper`) Actor

\[⭐$0.8/1k] Scrape NaukriGulf.com - the leading job portal for UAE, Saudi, Qatar, Kuwait, Bahrain and Oman. Search by keyword, location, experience and freshness. Extract titles, company details, descriptions, industry type, functional area, posted dates and more. Up to 10,000 results.

- **URL**: https://apify.com/epicscrapers/naukrigulf-jobs-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.80 / 1,000 results

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

## NaukriGulf Jobs Scraper ⭐

![NaukriGulf Jobs Scraper Banner](https://raw.githubusercontent.com/jwlben11/hosted-images/c72def4a4aaed9f912bc493106a19e694806bd02/naukrigulf-banner.svg)

**From $0.80 / 1,000 results** — Scrape job listings from **[naukrigulf.com](https://www.naukrigulf.com)** — the #1 job portal for the GCC region covering UAE, Saudi Arabia, Qatar, Oman, Kuwait, Bahrain, and Egypt.

Search by keyword, location, experience level, and freshness. Returns rich structured data including job titles, full descriptions (HTML + clean text), company profiles, industry type, functional area, posted dates, and more. Up to **10,000 results per run**. No login required. No API key needed.

---

### Why This Scraper?

| Feature                  | NaukriGulf Jobs Scraper ⭐ | easyapi       | stealth_mode  | memo23        |
| ------------------------ | ------------------------- | ------------- | ------------- | ------------- |
| **Price per 1K results** | **$0.80**                 | Not disclosed | $2.00         | $0.99         |
| **Max results per run**  | **10,000**                | Not specified | 20 per URL    | 10,000        |
| **Description format**   | **HTML + clean text**     | Raw HTML only | Raw HTML only | Raw HTML only |
| **Company profile**      | ✅ Full text               | Partial       | Partial       | Partial       |
| **Industry type**        | ✅ Parsed array            | ❌             | ❌             | ❌             |
| **Functional area**      | ✅ Parsed array            | ❌             | ❌             | ❌             |
| **Company logo URL**     | ✅ Included                | ✅ Included    | ✅ Included    | ✅ Included    |
| **Sponsored flag**       | ✅ Yes                     | ❌             | ❌             | ❌             |
| **Easy apply flag**      | ✅ Yes                     | ❌             | ❌             | ❌             |
| **Top employer flag**    | ✅ Yes                     | ❌             | ❌             | ❌             |
| **No Login **            | ✅ Yes                     | ✅ Yes         | ✅ Yes         | ✅ Yes         |

---

### 🚀 Features

- **Keyword search** — any job title, skill set, or company name
- **Location filter** — search by city or country across the GCC
- **Experience filter** — set minimum years of experience required
- **Freshness filter** — get jobs posted in the last 1, 3, 7, 15, 30, or 60 days
- **Country cluster filter** — advanced filtering by country ID for precise results
- **Full job descriptions** — both raw HTML and clean text versions
- **Company profiles** — full company descriptions from the employer
- **Industry & function** — parsed industry type and functional area arrays
- **Company logos** — employer logo URLs included where available
- **Sponsored & featured flags** — identify promoted listings at a glance
- **Auto-pagination** — automatically fetches all matching results up to your cap
- **No login required** — anonymous access, no account needed
- **No API key** — works out of the box

---

### 📋 What You Get

Every scraped job returns 29 fields of structured data:

| Field                   | Type      | Description                              | Example                                                      |
| ----------------------- | --------- | ---------------------------------------- | ------------------------------------------------------------ |
| `jobId`                 | string    | Unique job identifier on naukrigulf.com  | `190526000214`                                               |
| `title`                 | string    | Job title / designation                  | `Python Developer`                                           |
| `company`               | string    | Hiring company name                      | `TASC Outsourcing`                                           |
| `companyId`             | string    | Unique company identifier                | `23461`                                                      |
| `companySlug`           | string    | URL-friendly company ID                  | `tasc-outsourcing-jobs-cid-77310`                            |
| `companyUrl`            | string    | Full company profile URL                 | `https://www.naukrigulf.com/tasc-outsourcing-jobs-cid-77310` |
| `companyType`           | string    | Employer type (Consultant, Direct, etc.) | `Consultant`                                                 |
| `companyProfile`        | string    | Full company description text            | `As TASC Outsourcing, we delivered...`                       |
| `logoUrl`               | string \  | null                                     | Company logo image URL                                       | `https://media.naukrigulf.com/logo.png` |
| `location`              | string    | City and country of the job              | `Abu Dhabi - United Arab Emirates (UAE)`                     |
| `experienceMin`         | integer \ | null                                     | Minimum years of experience                                  | `8` |
| `experienceMax`         | integer \ | null                                     | Maximum years of experience                                  | `9` |
| `descriptionHtml`       | string    | Full job description in raw HTML         | `<p>About the Role:</p><ul>...`                              |
| `description`           | string    | Full job description in clean text       | `About the Role:\n- Design and develop...`                   |
| `jobUrl`                | string    | Relative path to the job page            | `python-developer-jobs-in-abu-dhabi...`                      |
| `url`                   | string    | Full clickable job listing URL           | `https://www.naukrigulf.com/python-developer...`             |
| `postedDate`            | integer \ | null                                     | UNIX timestamp (seconds) of posting                          | `1779163200` |
| `vacancies`             | integer \ | null                                     | Number of open positions                                     | `1` |
| `isEasyApply`           | boolean   | Supports one-click apply                 | `false`                                                      |
| `isSponsored`           | boolean   | Sponsored / paid listing                 | `false`                                                      |
| `isTopEmployer`         | boolean   | Company is a top employer                | `false`                                                      |
| `isConfidentialCompany` | boolean   | Company identity is hidden               | `false`                                                      |
| `industryType`          | string[]  | Industry categories                      | `["Other"]`                                                  |
| `functionalArea`        | string[]  | Functional area / department             | `["Other"]`                                                  |
| `keywords`              | string    | Search query used to find the job        | `Python Developer`                                           |
| `searchLocation`        | string    | Location filter used                     | `UAE`                                                        |
| `isConsultant`          | boolean   | Posted by a recruitment consultancy      | `true`                                                       |
| `jobSource`             | string    | Origin of the job listing                | `TAG`                                                        |
| `scrapedAt`             | string    | ISO 8601 scrape timestamp                | `2026-06-15T17:26:03.233Z`                                   |

---

### 💰 Pricing

**From $0.80 per 1,000 results** — charged only for items pushed to the dataset. No hidden fees, no minimums.

| Volume      | Estimated cost |
| ----------- | -------------- |
| 500 jobs    | ~$0.40         |
| 2,000 jobs  | ~$1.60         |
| 10,000 jobs | ~$8.00         |

Lightweight and fast — typically **2–3 compute units per 1,000 jobs**. No third-party fees.

---

### 📥 Input

| Input            | Type    | Required | Default | Description                                       |
| ---------------- | ------- | -------- | ------- | ------------------------------------------------- |
| `keywords`       | string  | ✅ Yes    | —       | Job title, skill, or company to search for        |
| `location`       | string  | ❌ No     | —       | City or country (e.g. `UAE`, `Dubai`, `Riyadh`)   |
| `experience`     | string  | ❌ No     | —       | Minimum years of experience (e.g. `3`)            |
| `freshness`      | string  | ❌ No     | —       | Days: `1`, `3`, `7`, `15`, `30`, or `60`          |
| `clusterCountry` | string  | ❌ No     | —       | Country ID (e.g. `17` = UAE, `14` = Saudi Arabia) |
| `maxResults`     | integer | ❌ No     | `50`    | Maximum jobs to scrape (max 10,000)               |
| `proxy`          | object  | ❌ No     | —       | Optional Apify proxy configuration                |

#### Example Input

```json
{
  "keywords": "Python Developer",
  "location": "UAE",
  "experience": "3",
  "freshness": "7",
  "maxResults": 100
}
````

#### Example Output

```json
{
  "jobId": "190526000214",
  "title": "Python Developer",
  "company": "TASC Outsourcing",
  "location": "Abu Dhabi - United Arab Emirates (UAE)",
  "experienceMin": 8,
  "experienceMax": 9,
  "description": "About the Role:\nWe are seeking a seasoned Python Developer...",
  "descriptionHtml": "<p>About the Role:</p>\n<p>We are seeking a seasoned Python Developer...</p>",
  "url": "https://www.naukrigulf.com/python-developer-jobs-in-abu-dhabi-uae-in-tasc-outsourcing-8-to-9-years-n-cd-23461-jid-190526000214",
  "postedDate": 1779163200,
  "isEasyApply": false,
  "isSponsored": false,
  "industryType": ["Other"],
  "functionalArea": ["Other"],
  "vacancies": 1,
  "companyType": "Consultant",
  "companyProfile": "As TASC Outsourcing, we delivered innovative, effective hiring solutions...",
  "logoUrl": null,
  "scrapedAt": "2026-06-15T17:26:03.233Z"
}
```

***

### 💡 Use Cases

#### Recruitment Intelligence

Track which companies are actively hiring across the GCC region. The scraper captures every job listing with company name, ID, type (direct employer vs consultant), and a full company profile description. Identify top employers by job volume across UAE, Saudi Arabia, Qatar, Kuwait, Bahrain, and Oman. Monitor hiring surges month-over-month by scheduling regular runs. Spot recruitment patterns by industry and location to build comprehensive databases of opportunities for candidate matching and market analysis.

Recruitment agencies specializing in Gulf placements can use this data to maintain up-to-date inventories of open positions, identify which clients are scaling up, and proactively reach out with candidate pipelines. HR teams can benchmark their own hiring activity against industry peers.

#### Salary Benchmarking

While naukrigulf.com does not always publish structured salary data, the job descriptions often contain compensation insights, benefit packages, and salary ranges. The scraper delivers both raw HTML and clean text versions of every description, making it easy to parse for currency amounts, housing allowances, transport benefits, and other GCC-specific compensation components.

Compare roles across Dubai, Riyadh, Doha, Abu Dhabi, and other major Gulf cities. Analyze how compensation varies by industry (oil & gas, finance, healthcare, technology) and experience level (entry, mid, senior). Use historical runs to track salary trends over time and make data-driven decisions on offer packages and market positioning.

#### Skill Demand Analysis

Identify trending skills, certifications, and qualifications across the Gulf job market. Each job listing includes title, description, and keywords — extract required skills, educational qualifications, and preferred certifications using the clean text or HTML description fields.

Track demand for specific technologies (Python, SAP, AI, cloud platforms), language requirements (Arabic proficiency levels, English fluency), and industry-specific expertise (oil & gas engineering, Islamic finance, healthcare regulation). Stay ahead of hiring trends and align training, recruitment, or business development strategies accordingly.

#### Market Entry Planning

Companies expanding into Gulf regions face unique challenges: understanding the competitive hiring landscape, navigating visa sponsorship norms, and identifying where talent concentrations exist. Scraped naukrigulf.com data provides direct insight into which employers are actively hiring, what qualifications they require, and where their operations are located.

Analyze job volumes by city to identify the most active hiring markets. Assess the balance between direct employers and recruitment consultants to understand hiring channel preferences. Use industry and functional area data to determine which sectors are growing in each GCC country. All this feeds into informed staffing strategies before opening new offices or launching regional operations.

#### Talent Mapping

Build structured databases of job openings by role, city, industry, and experience level. With 29 fields per job, including experience ranges, location, industry type, and functional area, you can slice and filter the dataset in any direction.

Track vacancy volumes over time to identify talent shortages and surpluses in specific roles or locations. Use the `postedDate` timestamp to understand listing velocity — are jobs being filled quickly or staying open? Run the scraper weekly to build a time-series dataset that reveals hiring trends, seasonal patterns, and shifting employer demand across the Gulf region.

#### Competitive Analysis

Monitor competitor hiring activity across the GCC without visiting their career pages individually. The scraper captures every job listing from naukrigulf.com — if a competitor is hiring, their postings appear in your dataset.

Identify which companies are scaling teams, what roles they're filling, and where they're expanding. The `isSponsored` and `isTopEmployer` flags reveal which companies are investing in recruitment visibility. Hiring volume is a leading indicator of business growth — a company posting 50 jobs this quarter vs 10 last quarter is likely expanding. Use this data to stay ahead of market movements and inform competitive strategy.

***

### ❓ Frequently Asked Questions

**Can I search by keyword?**

Yes. The `keywords` input accepts any job title, skill set, or company name. Example queries: `Python Developer`, `Accountant`, `Civil Engineer`, `Sales Manager`, `Data Scientist`, `Project Manager`, `HR Executive`, `Mechanical Engineer`. The search works across all industries and experience levels.

**How many jobs can I scrape in one run?**

Up to 10,000 jobs per run. The `maxResults` parameter lets you set any cap between 1 and 10,000. Default is 50. For large-scale market research, set it to 10,000 to get a comprehensive view of the GCC job market. The scraper automatically paginates through all results until it reaches your cap or exhausts available listings.

**Do I need an API key or account?**

No. The scraper works anonymously against naukrigulf.com's publicly available data. No login, no API key, no registration, no cookies required. Just set your search parameters and run.

**What countries / GCC regions are covered?**

All countries on naukrigulf.com: UAE (Dubai, Abu Dhabi, Sharjah, etc.), Saudi Arabia (Riyadh, Jeddah, Dammam), Qatar (Doha), Kuwait (Kuwait City), Bahrain (Manama), Oman (Muscat), and Egypt (Cairo, Alexandria). Use the `location` filter to narrow by city or country, or leave it empty for all regions.

**How fresh is the data?**

Use the `freshness` filter to restrict results to jobs posted in the last 1, 3, 7, 15, 30, or 60 days. Each job includes a `postedDate` field with the exact UNIX timestamp of when it was listed. Schedule weekly runs to maintain a continuously fresh dataset.

**What export formats are supported?**

The Apify platform supports multiple export formats from the Storage tab: JSON, JSONL, CSV, Excel (XLSX), HTML table, and XML. You can also access data programmatically via the Apify API for integration into your own pipelines.

**How is this different from other NaukriGulf scrapers?**

This scraper returns 29 structured fields per job — significantly more than competitors. Key differentiators:

- **Both HTML and clean text** descriptions (most scrapers give you only one)
- **Parsed industry type and functional area** as clean string arrays
- **Full company profiles** — not just company name, but the full employer description
- **Sponsored, top employer, easy apply, and consultant flags** — identify listing types at a glance
- **Competitive price** — from $0.80 per 1,000 results
- **No login, no API key** — just set your parameters and run

***

### 📚 Technical Details

#### How It Works

The scraper uses a two-phase approach:

1. **Search phase** — submits your query and paginates through all matching results, collecting job IDs and metadata
2. **Enrichment phase** — fetches full details (descriptions, company profiles, industry data) for each job concurrently

#### Error Handling

- **404 responses** — jobs that have been removed are skipped gracefully
- **Rate limiting (429)** — automatic retry with `Retry-After` header support
- **Server errors (503)** — exponential backoff with up to 3 retries
- **Network failures** — automatic retries with configurable concurrency

#### Data Integrity

- Each job gets a unique `jobId` from naukrigulf.com — no duplicates
- `scrapedAt` provides an ISO 8601 timestamp of when each job was collected
- Descriptions are preserved in both raw HTML and clean text formats

***

### SEO Keywords

naukrigulf jobs scraper, naukrigulf.com scraper, scrape naukrigulf.com, naukrigulf data extraction, naukrigulf job data, gulf jobs scraper, uae jobs scraper, dubai jobs scraper, saudi arabia jobs scraper, qatar jobs scraper, kuwait jobs scraper, bahrain jobs scraper, oman jobs scraper, gcc job scraper, middle east jobs scraper, naukrigulf job market data, gulf recruitment data, uae hiring data, dubai job market analysis, gulf talent mapping, middle east job board scraper, naukrigulf job details extractor, gulf job posting scraper, mena jobs data, apify naukrigulf actor, scrape gulf jobs, job market intelligence gulf, recruitment analytics uae

***

### ⚠️ Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by NaukriGulf.com, Info Edge (India) Limited, or any of their subsidiaries**. All trademarks are the property of their respective owners.

This Actor accesses only publicly available job listing data on `naukrigulf.com`. You are solely responsible for ensuring your use complies with the site's Terms of Service and applicable laws.

# Actor input Schema

## `keywords` (type: `string`):

Job title, skill, or company to search for. E.g. 'Python Developer', 'Accountant', 'Engineer'.

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

City or country to search in. E.g. 'UAE', 'Dubai', 'Abu Dhabi', 'Saudi Arabia'. Leave empty for all locations.

## `experience` (type: `string`):

Minimum years of experience required. E.g. '2' for 2+ years.

## `freshness` (type: `string`):

How recent the job posting is. Options: 1, 3, 7, 15, 30, 60 days.

## `clusterCountry` (type: `string`):

Advanced: Country cluster ID from the API (e.g. '17' = UAE, '3' = Egypt, '14' = Saudi Arabia). Use instead of 'location' for more precise filtering.

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

Maximum number of job listings to scrape. Default: 50.

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

Optional proxy configuration for geo-diverse scraping.

## Actor input object example

```json
{
  "keywords": "Python Developer",
  "maxResults": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Link to the default dataset containing all scraped job listings.

# 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": "Python Developer",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/naukrigulf-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 = {
    "keywords": "Python Developer",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/naukrigulf-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 '{
  "keywords": "Python Developer",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call epicscrapers/naukrigulf-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukrigulf Jobs Scraper",
        "description": "[⭐$0.8/1k] Scrape NaukriGulf.com - the leading job portal for UAE, Saudi, Qatar, Kuwait, Bahrain and Oman. Search by keyword, location, experience and freshness. Extract titles, company details, descriptions, industry type, functional area, posted dates and more. Up to 10,000 results.",
        "version": "0.0",
        "x-build-id": "u4ZIg2i4hsNQhV1XH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~naukrigulf-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-naukrigulf-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/epicscrapers~naukrigulf-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-naukrigulf-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/epicscrapers~naukrigulf-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-naukrigulf-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "string",
                        "description": "Job title, skill, or company to search for. E.g. 'Python Developer', 'Accountant', 'Engineer'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or country to search in. E.g. 'UAE', 'Dubai', 'Abu Dhabi', 'Saudi Arabia'. Leave empty for all locations."
                    },
                    "experience": {
                        "title": "Minimum Experience (Years)",
                        "type": "string",
                        "description": "Minimum years of experience required. E.g. '2' for 2+ years."
                    },
                    "freshness": {
                        "title": "Freshness (Days)",
                        "enum": [
                            "1",
                            "3",
                            "7",
                            "15",
                            "30",
                            "60"
                        ],
                        "type": "string",
                        "description": "How recent the job posting is. Options: 1, 3, 7, 15, 30, 60 days."
                    },
                    "clusterCountry": {
                        "title": "Country Filter ID",
                        "type": "string",
                        "description": "Advanced: Country cluster ID from the API (e.g. '17' = UAE, '3' = Egypt, '14' = Saudi Arabia). Use instead of 'location' for more precise filtering."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape. Default: 50.",
                        "default": 50
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy configuration for geo-diverse scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
