# Bayt Scraper (`santamaria-automations/bayt-scraper`) Actor

Scrape Bayt.com jobs across the UAE, Saudi Arabia, Qatar, Kuwait, Egypt, Jordan and more. Returns title, company, location, salary, full description (text, HTML, Markdown), skills, education, experience, dates and apply method. Pay per result, $0.003 per job or $0.005 with full details.

- **URL**: https://apify.com/santamaria-automations/bayt-scraper.md
- **Developed by:** [NanoScrape](https://apify.com/santamaria-automations) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 actor starts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Bayt Scraper - Middle East and North Africa Jobs, Salaries, Companies

Pull live job listings from [Bayt.com](https://www.bayt.com), the largest job board in the Middle East and North Africa, covering the UAE, Saudi Arabia, Qatar, Kuwait, Bahrain, Oman, Jordan, Lebanon, Egypt, Iraq, Morocco, Tunisia, Algeria, Libya, Pakistan and India. Each record includes job title, employer, city and country, structured salary (min, max, currency, period), employment type, and the posting time down to the minute. With detail mode on, you also get the full job description (text, HTML and Markdown), skills, required education and experience, career level, number of open positions, employer size and industry, expiry date, and how to apply. No API key, no login.

**Freshest jobs first:** the default `sortBy: "newest"` uses Bayt's own date-descending sort, and every row carries an exact UTC timestamp in `posted_at_datetime`, so scheduled runs can stop at the last job they already saw.

### Sample output

```json
{
  "id": "5487963",
  "title": "Senior Sales Consultant in Antelias",
  "company_name": "PrimeTalent",
  "company": "PrimeTalent",
  "company_logo_url": "https://secure.b8cdn.com/58x58/images/logo/93/2176093_logo_264x120_1736268899_n.png",
  "company_profile_url": "https://www.bayt.com/en/company/primetalent-2176093/",
  "location": "Antelias",
  "region": "Antelias",
  "country": "LB",
  "employment_type": "full-time",
  "salary_min": 1000,
  "salary_max": 1500,
  "salary_currency": "USD",
  "salary_period": "month",
  "salary_text": "USD 1,000 - 1,500 per month",
  "description_snippet": "PRIMETALENT IS HIRING. We are hiring a Senior Sales Consultant for a reputable company in Antelias area...",
  "description_full": "PRIMETALENT IS HIRING. We are hiring a Senior Sales Consultant for a reputable company in Antelias area...",
  "description_html": "<p><b>PRIMETALENT IS HIRING</b></p><p>We are hiring a Senior Sales Consultant...</p>",
  "description_md": "**PRIMETALENT IS HIRING**\n\nWe are hiring a **Senior Sales Consultant** for a reputable company in Antelias area...",
  "requirements": ["Bachelor / Technical degree in Business, Marketing or Engineering", "5+ years of experience in B2B sales or account management"],
  "skills": [],
  "experience_years": "4+ years",
  "experience_required": "4+ years",
  "headcount": 1,
  "company_size": "1-9 Employees",
  "company_industry": "Accounting",
  "apply_method": "Apply on company site",
  "is_easy_apply": false,
  "is_aggregated": false,
  "posted_at": "2026-09-29",
  "posted_at_text": "1 hour ago",
  "posted_at_datetime": "2026-09-29T09:19:21Z",
  "expires_at": "2026-11-28",
  "job_url": "https://www.bayt.com/en/lebanon/jobs/senior-sales-consultant-in-antelias-5487963/",
  "source_url": "https://www.bayt.com/en/lebanon/jobs/senior-sales-consultant-in-antelias-5487963/",
  "apply_url": "https://www.bayt.com/en/lebanon/jobs/senior-sales-consultant-in-antelias-5487963/",
  "source_platform": "bayt.com",
  "search_query": "sales",
  "scraped_at": "2026-09-29T10:44:40Z"
}
```

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | array of strings | `["Software Engineer"]` in the UI | Keywords. Each runs as its own search. |
| `searchUrls` | array of strings | none | Bayt search result URLs with your filters applied. |
| `country` | string | `international` | `uae`, `saudi-arabia`, `qatar`, `kuwait`, `bahrain`, `oman`, `jordan`, `lebanon`, `egypt`, `iraq`, `morocco`, `tunisia`, `algeria`, `libya`, `pakistan`, `india`, or `international` for all. Ignored for Search URLs. |
| `location` | string | none | City, for example `Dubai`, `Riyadh` or `Cairo`. Uses Bayt's city pages. With `country: international`, a known city selects its country automatically. |
| `maxResultsPerQuery` | integer | 10 | Cap per keyword or search URL. |
| `maxResults` | integer | 10 | Total cap across all queries. |
| `includeJobDetails` | boolean | `true` | Fetch each job page for the full description and detail fields. |
| `includeCompanyDetails` | boolean | `false` | Fetch each employer's Bayt company page once per run and add company website, headquarters, size, industry, followers and About us text to every row of that employer. Billed per unique employer. |
| `sortBy` | string | `newest` | `newest` (Bayt date-descending sort) or `relevance` (Bayt default ranking). |
| `postedWithinDays` | integer | none | Only jobs posted within N days. Bayt has 1, 7 and 30 day windows, so N is rounded up to the nearest one. |
| `maxConcurrency` | integer | 5 | Detail and company pages fetched in parallel (1 to 20). Each worker uses its own fresh session, so a higher value is a safe speedup. |

An empty input `{}` works and returns the 10 newest jobs across all countries with full details.

**Per-query caps.** `maxResults` is the total ceiling. If it is lower than `maxResultsPerQuery` times the number of keywords, the first keywords fill it and later ones get no results. For 2 keywords with 20 jobs each, send `maxResultsPerQuery: 20` and `maxResults: 40`. A job that matches several keywords is returned once, under the first keyword that found it.

#### Input examples

Newest 100 software jobs in the UAE with full details:

```json
{
  "searchQueries": ["software engineer"],
  "country": "uae",
  "maxResultsPerQuery": 100,
  "maxResults": 100,
  "includeJobDetails": true,
  "sortBy": "newest"
}
```

Two keywords, 20 jobs each, across all countries:

```json
{
  "searchQueries": ["data scientist", "machine learning engineer"],
  "country": "international",
  "maxResultsPerQuery": 20,
  "maxResults": 40,
  "includeJobDetails": true
}
```

A Bayt search URL, list data only:

```json
{
  "searchUrls": ["https://www.bayt.com/en/saudi-arabia/jobs/marketing-manager-jobs/"],
  "maxResults": 500,
  "includeJobDetails": false
}
```

Jobs with company details, for example physiotherapist jobs in Kuwait:

```json
{
  "searchQueries": ["physiotherapist"],
  "country": "kuwait",
  "maxResults": 10,
  "includeCompanyDetails": true
}
```

Each row then carries the employer fields, for example:

```json
{
  "company_name": "SESC Sports and Exercise Science",
  "company_profile_url": "https://www.bayt.com/en/company/sesc-sports-and-exercise-science-2165643/",
  "company_website": "https://sesc.net/",
  "company_headquarters": "Al Kuwait, Kuwait",
  "company_size": "50-99 Employees",
  "company_industry": "Personal Care Centers",
  "company_followers_text": "2K+ Followers",
  "company_about": "..."
}
```

### Output fields

**Core**

- `id`: Bayt job ID (stable dedup key).
- `title`: Job title.
- `company_name`: Employer name (canonical). `Confidential Company` when the employer is hidden.
- `company`: Deprecated duplicate of `company_name`, see Deprecation notes below.
- `company_logo_url`: Employer logo, `null` when Bayt shows the placeholder.
- `company_profile_url`: Employer profile page on Bayt (canonical). `company_url` is a deprecated alias with the same value.
- `location`: City.
- `region`: Region or emirate of the job (detail mode).
- `country`: ISO code (`AE`, `SA`, `QA`, `KW`, `BH`, `OM`, `JO`, `LB`, `EG`, and so on).
- `is_aggregated`: `true` when Bayt collected the job from an external source instead of a direct employer post.

**Employment and salary**

- `employment_type`: `full-time`, `part-time`, `contract`, `temporary`, `internship`, `freelance`.
- `remote_option`: `remote` or `hybrid` when the listing says so, otherwise `null`.
- `salary_min`, `salary_max`, `salary_currency`, `salary_period`: Parsed when the employer publishes a pay range. `null` otherwise.
- `salary_text`: The pay string as shown.

**Description**

- `description_snippet`: Short teaser (search page summary, or the first 500 characters in detail mode).
- `description_full`: Full plain-text body (detail mode).
- `description_html`: The same body as HTML (detail mode).
- `description_md`: The same body as Markdown (detail mode).
- `requirements`: Requirement lines extracted from the description or the employer's qualifications box (detail mode).
- `skills`: Skill tags the employer entered (detail mode). Empty when the employer wrote free text instead.

**Role details** (detail mode)

- `career_level`, `position_level`: Career level printed by Bayt, for example `Entry level`, `Mid career`, `Management`.
- `experience_years`, `experience_required`: Required experience, for example `3+ years`.
- `education_required`: Required degree, for example `Bachelor's degree / higher diploma`.
- `headcount`: Number of open positions.
- `preferred_nationality`: Preferred candidate nationality when the employer set one.
- `preferred_gender`: Preferred candidate gender when the employer set one.
- `major`: Preferred field of study or major when the employer set one.
- `citizenship_requirement`: Citizenship restriction shown on the listing, for example `UAE nationals`.
- `company_size`: Employer headcount range, for example `100-499 Employees`.
- `company_industry`: Employer industry.
- `apply_method`: `Easy Apply` or `Apply on company site`.
- `is_easy_apply`: `true` when the job accepts direct applications on Bayt.

**Company details** (only with `includeCompanyDetails: true`, otherwise `null`)

- `company_website`: The employer's own website.
- `company_headquarters`: Headquarters as printed on the company page, for example `Al Kuwait, Kuwait`.
- `company_size`: Headcount range as printed, for example `50-99 Employees`.
- `company_industry`: Industry. The job page value is kept when present; the company page only fills it when empty.
- `company_followers_text`: Follower count as printed by Bayt, for example `2K+ Followers`. Bayt-specific.
- `company_about`: The employer's About us text.

Employers that hide their name (`Confidential Company`) have no company page, so all company fields stay `null` for their jobs. Companies omit items on their page, so any single field can be `null`.

**Dates and links**

- `posted_at`: Posting date (`YYYY-MM-DD`).
- `posted_at_datetime`: Exact posting time in UTC (ISO 8601).
- `posted_at_text`: Age as Bayt shows it, for example `3 hours ago`.
- `expires_at`: Listing expiry date (detail mode).
- `job_url`: Canonical Bayt job page. `source_url` carries the same value.
- `apply_url`: Where to apply. Bayt routes applications through the job page, so this equals `job_url`; use `apply_method` to see whether it is Easy Apply or an employer site.
- `source_platform`: Always `bayt.com`.
- `search_query`: The plain keyword exactly as you gave it (for example `accountant`, even when `location` is set). `(all jobs)` style text is used only when a run has no keyword.
- `scraped_at`: UTC timestamp when the row was written.

Fields Bayt does not show publicly are not available: recruiter name, email and phone are not part of Bayt pages. The employer website is available with `includeCompanyDetails`; pair it with a website contact tool to find emails.

#### Deprecation notes

The following field names are deprecated and will be removed after **2027-09-29** (one-year backward-compatibility window):

- `company` -> use `company_name` (canonical since 2026-09-29)
- `company_url` -> use `company_profile_url` (canonical since 2026-09-29). `company_url` is an alias with the same value.
- Input `mode` -> use `includeJobDetails` (`mode: "fast"` still works and turns details off)

Both old and new fields are emitted in every dataset row during the window.

### Pricing

Pay per event. You are charged only for what you get.

| Event | Price |
|-------|-------|
| Actor start | $0.001 per run start |
| Search result (every job returned) | $0.003 per job returned (about $3 per 1,000) |
| Detail result (`includeJobDetails: true`) | +$0.005 per job enriched with full details (about $8 per 1,000 jobs with details) |
| Company detail result (`includeCompanyDetails: true`) | $0.005 per unique employer whose company page was read |

Company details are billed once per unique employer per run, no matter how many of its jobs are returned or how many keywords found them. An employer whose page could not be read is not billed.

Every returned job is billed the search result. A job whose detail page was parsed is billed the detail result on top of it. A job whose detail page could not be read is billed the search result only.

### Speed and scale

- List-only mode reads 30 jobs per page and finishes a few hundred jobs in well under a minute.
- Detail mode fetches one page per job. A 30-job run takes about one minute at the default `maxConcurrency` of 5.
- Bayt serves up to about 1,500 results per search (50 pages of 30). For larger pulls, split by `country`, `location` or keyword.

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client: Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, or custom agents.

Configure the MCP server with Bayt Scraper preconfigured at `mcp.apify.com?tools=santamaria-automations/bayt-scraper`. You can connect to the Apify MCP Server using clients like Tester MCP Client, or any other MCP client of your choice.

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

For per-tool schemas and copy-paste snippets for MCP clients, see the [MCP tab](https://console.apify.com/actors/GKusrsE5CGOZd8xW7/info/api/mcp?build=latest).

See the [auto-generated API tab](https://console.apify.com/actors/GKusrsE5CGOZd8xW7/info/api) for language-specific examples (cURL, JS, Python, .NET, Ruby, PHP).

### Why this actor

- Covers 16 Middle East, North Africa and South Asia markets from one input, or one country at a time.
- Real newest-first ordering with an exact UTC timestamp on every row, made for scheduled monitoring.
- Structured salary in the local currency (AED, SAR, KWD, QAR, USD and others) with min, max and period.
- Full description in text, HTML and Markdown, plus skills, education, experience and headcount in detail mode.
- Failed detail fetches are not billed at the detail rate.
- Optional employer enrichment (website, headquarters, size, industry, About us) billed once per unique employer.

### Common use cases

- Track new UAE and Saudi hiring by keyword every morning and push new roles into a Slack channel.
- Benchmark posted salary ranges for the same job title across Dubai, Riyadh, Doha and Cairo.
- Build a list of active employers with size and industry to target for recruitment services.
- Feed job descriptions in Markdown into an LLM to match candidates or classify roles.

### Notes and limits

- Bayt lists nearly every job as `full-time` on its pages, so `employment_type` rarely varies.
- `expires_at` is the closing date Bayt sets on the listing, usually 30 to 120 days after posting. It is not always an employer deadline.
- Many Bayt listings do not publish a salary. `salary_min` and `salary_max` are `null` then.
- **City filter:** `location` uses Bayt's own city pages (for example jobs in Dubai). Bayt has no city pages under `international`, so a known city there is mapped to its country. For a city Bayt has no page for, the actor searches the whole country and keeps only rows whose location contains that city, so you may get fewer results than `maxResults`.
- Some employers are hidden and appear as `Confidential Company`.
- Jobs posted in Arabic are translated to English by Bayt, and the actor returns the English text.
- Some listings are aggregated from external sources (`is_aggregated: true`) and carry fewer details.
- Bayt limits how many results a single search can page through. If you need more, add a `location` or split by keyword.

### Related actors

- [Website Job Extractor](https://apify.com/santamaria-automations/website-job-extractor): jobs from any company career page.
- [Indeed Scraper](https://apify.com/santamaria-automations/indeed-http-scraper): Indeed listings across many countries, including the Gulf.
- [Glassdoor Scraper](https://apify.com/santamaria-automations/glassdoor-scraper): jobs with salary estimates and company ratings.
- [Naukri Scraper](https://apify.com/santamaria-automations/naukri-scraper): India's largest job board, a common pair for Gulf hiring.
- [Hays Scraper](https://apify.com/santamaria-automations/hays-scraper): recruitment agency roles worldwide, including the Middle East.
- [Michael Page Scraper](https://apify.com/santamaria-automations/michaelpage-scraper): executive and specialist agency vacancies.

### Support

- **Questions or issues?** Email contact@nanoscrape.com, we typically reply within 6 hours. You can also open a ticket in the [Issues tab](https://console.apify.com/actors/GKusrsE5CGOZd8xW7/info/issues) on the actor page.
- **Feature request for this actor?** Open a ticket in the [Issues tab](https://console.apify.com/actors/GKusrsE5CGOZd8xW7/info/issues) or email contact@nanoscrape.com with the field you need and, if possible, a Bayt URL that shows it live.
- **Need a scraper for a job board we don't cover yet?** Email contact@nanoscrape.com with the target site and your rough usage volume. We ship one-off boards regularly.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more search keywords (e.g. 'Software Engineer', 'Marketing Manager'). Each runs as a separate search. Results are deduplicated across queries. If both this and Search URLs are empty, the latest jobs for the chosen country are returned.

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

Paste one or more Bayt.com search URLs. Go to bayt.com, set your filters, and copy the URL. All filters are preserved automatically.

## `country` (type: `string`):

Bayt.com country to search. Not needed when using Search URLs (country is in the URL).

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

City filter, for example Dubai, Riyadh or Cairo. Uses Bayt's own city pages, so results are in that city. With Country set to International, a known city picks its country automatically (Dubai searches the UAE). For a city Bayt has no page for, the search runs country-wide and rows are filtered to that city, so it may return fewer results. Leave empty for the whole country.

## `maxResultsPerQuery` (type: `integer`):

Maximum results per search keyword or search URL. Set maxResults to at least this value times the number of queries, otherwise the first queries fill the total cap and later queries get no results.

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

Total cap across all queries and search URLs. Set to 0 for the default of 10.

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

Fetch each job's detail page for the full description (text, HTML, Markdown), structured salary, expiry date, skills, education, experience, headcount, company size and industry, and apply method. Turn off for a faster, cheaper SERP-only run (title, company, location, salary text, snippet). Every job costs $0.003; jobs with full details cost an extra $0.005.

## `includeCompanyDetails` (type: `boolean`):

Fetch each employer's Bayt company page once per run for the company website, headquarters, size, industry, follower count and About us text. Every unique employer costs an extra $0.005 (company-detail-result), no matter how many of its jobs are returned. Confidential employers have no company page and are skipped. Off by default.

## `postedWithinDays` (type: `integer`):

Only jobs posted or refreshed within this many days. Bayt supports three windows, so the value is rounded up to the nearest one: 1 day, 7 days or 30 days. Leave empty for no date filter. Applied to keywords and to Search URLs that do not already set a date filter.

## `sortBy` (type: `string`):

Server-side sort order. 'newest' sends ?options\[sort]\[]=d (PHP bracket-array notation, date descending). 'relevance' omits the sort param and uses Bayt's default relevance ordering.

## `maxConcurrency` (type: `integer`):

Number of job detail pages fetched in parallel. Higher is faster. Each worker uses its own fresh session, so raising this is a safe speedup. Default 5.

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

DEPRECATED (2026-09-29). Use `includeJobDetails` instead. 'fast' returns SERP data only and behaves like includeJobDetails=false. Setting either one to fast/false turns detail fetching off. Kept so saved tasks keep working; will be removed after 2027-09-29.

## Actor input object example

```json
{
  "searchQueries": [
    "Software Engineer"
  ],
  "country": "international",
  "location": "Dubai",
  "maxResultsPerQuery": 10,
  "maxResults": 10,
  "includeJobDetails": true,
  "includeCompanyDetails": false,
  "sortBy": "newest",
  "maxConcurrency": 5,
  "mode": "full"
}
```

# Actor output Schema

## `jobListings` (type: `string`):

Dataset containing scraped Bayt.com job listings. Each record includes: id, title, company\_name (`company` is a deprecated duplicate removed after 2027-09-29), company\_logo\_url, company\_profile\_url (`company_url` is a deprecated duplicate removed after 2027-09-29), location, region, country (ISO), employment\_type, remote\_option, salary (min/max/currency/period/text), description (snippet + full + html + md), requirements, skills, career\_level, position\_level, experience\_years, experience\_required, education\_required, headcount, company\_size, company\_industry, company\_website, company\_headquarters, company\_about, company\_followers\_text (the last four company\_\* fields need includeCompanyDetails), preferred\_nationality, preferred\_gender, major, citizenship\_requirement, posted\_at, posted\_at\_text, posted\_at\_datetime, expires\_at, job\_url, source\_url, apply\_url, apply\_method, is\_easy\_apply, is\_aggregated, search\_query, scraped\_at. Detail-only fields (full description, skills, education, headcount, company size and industry, apply method) need includeJobDetails.

## `company_name` (type: `string`):

Employer name (canonical).

## `company` (type: `string`):

DEPRECATED (2026-09-29): use `company_name`. This field will be removed after 2027-09-29.

## `company_profile_url` (type: `string`):

Employer profile page on Bayt (canonical).

## `company_url` (type: `string`):

DEPRECATED (2026-09-29): alias of `company_profile_url`, use that instead. This field will be removed after 2027-09-29.

## `company_website` (type: `string`):

Employer's own website from its Bayt company page (includeCompanyDetails).

## `company_headquarters` (type: `string`):

Employer headquarters from its Bayt company page (includeCompanyDetails).

## `company_size` (type: `string`):

Employer headcount range, e.g. 50-99 Employees.

## `company_industry` (type: `string`):

Employer industry as printed by Bayt.

## `company_about` (type: `string`):

Employer 'About us' text (includeCompanyDetails).

## `company_followers_text` (type: `string`):

Follower count text, e.g. 2K+ Followers (includeCompanyDetails).

# 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 = {
    "searchQueries": [
        "Software Engineer"
    ],
    "maxResultsPerQuery": 10,
    "includeJobDetails": true,
    "sortBy": "newest",
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/bayt-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 = {
    "searchQueries": ["Software Engineer"],
    "maxResultsPerQuery": 10,
    "includeJobDetails": True,
    "sortBy": "newest",
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("santamaria-automations/bayt-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 '{
  "searchQueries": [
    "Software Engineer"
  ],
  "maxResultsPerQuery": 10,
  "includeJobDetails": true,
  "sortBy": "newest",
  "maxConcurrency": 5
}' |
apify call santamaria-automations/bayt-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,santamaria-automations/bayt-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/GKusrsE5CGOZd8xW7/builds/Q10CIwbveCgxuAVWz/openapi.json