# Bayt Job Listings Extractor (`kawsar/bayt-job-listings-extractor`) Actor

Bayt job listings scraper that pulls job titles, companies, salaries, and locations from any Bayt.com search URL, pages through results automatically, so you get MENA job market data as clean JSON without manual browsing.

- **URL**: https://apify.com/kawsar/bayt-job-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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

## Bayt Job Listings Extractor

Pulls job listings from Bayt.com, a major job portal for the Middle East and North Africa. Give it one or more Bayt.com search URLs and it scrapes job titles, company names, city and country locations, salary ranges, career levels, experience requirements, job summaries, and posting dates. The output is structured JSON. Pagination is handled automatically.

Bayt.com covers job markets across the UAE, Saudi Arabia, Qatar, Kuwait, Egypt, Lebanon, Jordan, and other MENA countries. This actor works on any Bayt.com search results URL, including country pages, keyword searches, city-filtered results, and searches with any filters applied.

### What it collects

Every job listing card on Bayt.com exposes the following data. Fields marked optional appear on some listings and are `null` when not present.

| Field | Always present | Description |
|---|---|---|
| jobId | Yes | Unique numeric ID for the listing on Bayt.com |
| jobTitle | Yes | Job title as shown on the card |
| jobUrl | Yes | Full URL of the job listing page |
| companyName | Yes | Name of the hiring company |
| companyUrl | Yes | URL of the company profile on Bayt.com |
| companyLogoUrl | Yes | URL of the company logo image |
| city | Yes | City where the role is based |
| country | Yes | Country where the role is based |
| jobSummary | Yes | AI-generated summary shown on the search card |
| careerLevel | Yes | Seniority label (Entry level, Mid career, Senior executive, etc.) |
| yearsOfExperience | Optional | Experience range parsed from the career label (e.g. 5-7 Years of Experience) |
| salary | Optional | Salary range if the employer chose to display it |
| workType | Optional | Hybrid or Remote if specified |
| citizenshipReq | Optional | Nationality restriction if specified (e.g. Saudi nationals) |
| postedTimestamp | Yes | Unix timestamp (seconds) of the posting date |
| postedDate | Yes | ISO 8601 UTC datetime string of the posting date |
| postedDateText | Yes | Relative date as shown on the page (e.g. 4 days ago) |
| isEasyApply | Yes | true if the listing has a one-click apply button |
| isExternal | Yes | true if the listing links to an external site |
| scrapedAt | Yes | ISO 8601 UTC timestamp of when this record was extracted |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| startUrls | Array | — | One or more Bayt.com job search URLs to scrape |
| maxItems | Integer | 25 | Max job listings to extract per URL |
| requestTimeoutSecs | Integer | 30 | Per-request timeout in seconds |

#### Example: single search

```json
{
  "startUrls": ["https://www.bayt.com/en/uae/jobs/data-analyst-jobs/"],
  "maxItems": 75
}
````

#### Example: multiple countries, same role

```json
{
  "startUrls": [
    "https://www.bayt.com/en/uae/jobs/software-engineer-jobs/",
    "https://www.bayt.com/en/saudi-arabia/jobs/software-engineer-jobs/",
    "https://www.bayt.com/en/qatar/jobs/software-engineer-jobs/"
  ],
  "maxItems": 50
}
```

#### Example: broad country-level collection

```json
{
  "startUrls": [
    "https://www.bayt.com/en/uae/jobs/",
    "https://www.bayt.com/en/saudi-arabia/jobs/",
    "https://www.bayt.com/en/egypt/jobs/"
  ],
  "maxItems": 100
}
```

### Output

Each job is saved as one JSON record in the Apify dataset. Results are available as JSON, CSV, or Excel from the Storage tab after the run finishes.

#### Example record

```json
{
  "jobId": "5461128",
  "jobTitle": "Unreal Engine Gameplay Programmer",
  "jobUrl": "https://www.bayt.com/en/qatar/jobs/unreal-engine-gameplay-programmer-5461128/",
  "companyName": "Dunetech Studios",
  "companyUrl": "https://www.bayt.com/en/company/dunetech-studios-2304796/",
  "companyLogoUrl": "https://secure.b8cdn.com/58x58/images/logo/96/2304796_logo_n.png",
  "city": "Doha",
  "country": "Qatar",
  "jobSummary": "A unique opportunity for an Unreal Engine Gameplay Programmer at a small independent studio focused on creating exceptional interactive experiences.",
  "careerLevel": "Entry level",
  "yearsOfExperience": null,
  "salary": null,
  "workType": null,
  "citizenshipReq": null,
  "postedTimestamp": 1781095408,
  "postedDate": "2025-04-07T10:43:28+00:00",
  "postedDateText": "21 hours ago",
  "isEasyApply": true,
  "isExternal": true,
  "scrapedAt": "2025-04-08T08:12:34.123456+00:00"
}
```

### Common uses

- **Salary research**: collect salary ranges for a specific role across different MENA countries and compare compensation by location
- **Hiring trend tracking**: run the actor weekly on industry-specific search URLs to see which companies are growing and how fast
- **Competitor monitoring**: watch job postings from specific companies to understand their expansion and skill priorities
- **Job dataset creation**: build training or benchmark datasets for HR analytics, NLP models, or job recommendation systems
- **Recruitment pipeline**: feed fresh listings into a downstream workflow to automatically match candidates

### How to run

1. Open the Input tab
2. Paste one or more Bayt.com job search URLs into the Start URLs field
3. Set Max Items per URL to control how much data to collect
4. Click Start
5. Download results from the Storage tab when the run finishes

### URL formats that work

The actor accepts any standard Bayt.com search results URL:

- Country page: `https://www.bayt.com/en/uae/jobs/`
- Keyword search: `https://www.bayt.com/en/international/jobs/software-engineer-jobs/`
- City search: `https://www.bayt.com/en/uae/jobs/software-engineer-jobs-in-dubai/`
- Any search URL with filters copied directly from the Bayt.com results page

### Pagination

Each URL is scraped page by page. The actor reads the `next` link in the page to find the next results page and continues until the per-URL item limit is reached or there are no more pages.

### Optional fields

`salary`, `workType`, `citizenshipReq`, and `yearsOfExperience` appear on some listings and not others. Bayt.com employers choose whether to display salary. Work type and citizenship requirements are only listed when the employer fills them in. When not present, these fields are `null` in the output.

### Rate and volume

Bayt.com shows roughly 20 to 30 job cards per page. At the default setting of 25 items per URL, the actor usually finishes in one or two pages. Increase `maxItems` to collect more per URL. Large runs over many URLs work well on the Apify platform.

# Actor input Schema

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

One or more Bayt.com job search URLs to scrape. Each must be a bayt.com URL.

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

Maximum number of job listings to extract per URL.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.bayt.com/en/uae/jobs/data-analyst-jobs/",
    "https://www.bayt.com/en/saudi-arabia/jobs/"
  ],
  "maxItems": 25,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "startUrls": [
        "https://www.bayt.com/en/international/jobs/software-engineer-jobs/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/bayt-job-listings-extractor").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 = { "startUrls": ["https://www.bayt.com/en/international/jobs/software-engineer-jobs/"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/bayt-job-listings-extractor").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 '{
  "startUrls": [
    "https://www.bayt.com/en/international/jobs/software-engineer-jobs/"
  ]
}' |
apify call kawsar/bayt-job-listings-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bayt Job Listings Extractor",
        "description": "Bayt job listings scraper that pulls job titles, companies, salaries, and locations from any Bayt.com search URL, pages through results automatically, so you get MENA job market data as clean JSON without manual browsing.",
        "version": "0.0",
        "x-build-id": "8qOQVsEfHkuAO5xfI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~bayt-job-listings-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-bayt-job-listings-extractor",
                "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/kawsar~bayt-job-listings-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-bayt-job-listings-extractor",
                "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/kawsar~bayt-job-listings-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-bayt-job-listings-extractor",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Bayt.com job search URLs to scrape. Each must be a bayt.com URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per URL",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to extract per URL.",
                        "default": 25
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
