# Drushim.co.il Jobs Scraper (`automation-lab/drushim-il-jobs-scraper`) Actor

Extract public Israeli job listings from Drushim by keyword, filtered search page, category, region, or exact vacancy URL.

- **URL**: https://apify.com/automation-lab/drushim-il-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Drushim.co.il Jobs Scraper

Extract structured Israeli job listings from Drushim.co.il by keyword, filtered search page, category, region, or exact vacancy URL.

The Actor returns full descriptions and requirements—not just search-card previews—plus employer details, locations, coordinates, employment type, experience, salary data when published, and direct application links.

Use it to refresh an Israeli vacancy feed, monitor employer hiring activity, source candidates, or measure labor-market demand without building and maintaining your own Drushim crawler.

### What does Drushim.co.il Jobs Scraper do?

Drushim.co.il Jobs Scraper turns public Drushim vacancies into export-ready records.

It can:

- 🔎 Search with Hebrew or English keywords
- 🧭 Follow Drushim category, subcategory, area, and keyword URLs
- 🎯 Extract one or more exact job URLs
- 📄 Return full job descriptions and requirements
- 🏢 Capture employer names, profiles, IDs, and logos
- 📍 Return cities, regions, latitude, and longitude when available
- 💼 Capture experience and employment type
- 💰 Preserve salary and benefits information when Drushim publishes it
- 🔗 Return canonical job and application URLs
- ♻️ Deduplicate jobs across overlapping inputs

Every dataset row represents one public Drushim job.

### Who is it for?

#### Recruiters and staffing firms

Refresh sourcing lists, discover newly advertised roles, and segment vacancies by location or required experience.

#### Job aggregators

Feed normalized Israeli job records into a search index, newsletter, portal, or matching product.

#### Sales and market-intelligence teams

Use hiring activity as a signal that a company is growing, entering a region, or investing in a function.

#### Labor-market analysts

Track demand by occupation, employer, category, region, and employment type over scheduled runs.

#### Developers and data teams

Receive JSON, CSV, Excel, XML, or RSS-ready dataset output without maintaining source-specific parsing code.

### Why use this Drushim job extractor?

Drushim pages are Hebrew-first and contain nested source-specific structures.

This Actor handles that normalization for you.

- **Full-detail rows:** descriptions and requirements are included in search results.
- **Stable identity:** `jobId` supports deduplication and change tracking.
- **Multiple discovery routes:** keywords, filtered search URLs, and exact jobs work together.
- **Typed output:** IDs, numbers, booleans, arrays, timestamps, and URLs retain useful types.
- **Hebrew-safe:** right-to-left text remains valid Unicode.
- **Efficient HTTP extraction:** no browser is required for the current public source.
- **Bounded runs:** `maxItems` controls volume and spend.

### What Drushim job data can I extract?

| Field | Description |
|---|---|
| `jobId` | Stable Drushim vacancy ID |
| `listingId` | Related listing/tracking ID when available |
| `url` | Canonical public job URL |
| `title` | Job title |
| `employer` | Employer or advertiser name |
| `employerId` | Drushim employer ID |
| `employerUrl` | Public employer profile |
| `locations` | Advertised cities or areas |
| `addresses` | City and geographic coordinates |
| `regions` | Drushim region labels |
| `categories` | Top-level job categories |
| `subcategories` | Detailed job disciplines |
| `experience` | Advertised experience level |
| `employmentTypes` | Full-time, part-time, temporary, and other scopes |
| `postingAge` | Human-readable freshness label |
| `postedAt` | Original posting timestamp when available |
| `updatedAt` | Most recent display/update timestamp |
| `description` | Full plain-text job description |
| `requirements` | Full plain-text requirements |
| `salary`, `salaryText` | Published compensation data |
| `benefits` | Published job benefits |
| `applyUrl` | Direct Drushim application route |
| `allowsNoCv` | Whether applying without a CV is allowed |
| `sourceSearchUrl` | Search provenance for the row |
| `scrapedAt` | UTC extraction time |

Optional fields are omitted when the source does not publish them.

### How to search Drushim jobs

1. Open the Actor input page.
2. Add one or more Hebrew or English values under **Job keywords**.
3. Optionally add category, region, experience, or scope IDs.
4. Set a small `maxItems` for your first run.
5. Click **Start**.
6. Open the Dataset tab to preview or export results.

A simple input is:

```json
{
  "keywords": ["Java", "מנהל מוצר"],
  "maxItems": 50
}
````

### How to scrape filtered Drushim search pages

Paste public Drushim URLs into `searchUrls`.

Supported patterns include:

- `https://www.drushim.co.il/jobs/search/Java/`
- `https://www.drushim.co.il/jobs/cat6/`
- `https://www.drushim.co.il/jobs/subcat/68/`
- `https://www.drushim.co.il/jobs/area/21-22/`
- Drushim search URLs containing supported query filters

Example:

```json
{
  "searchUrls": [
    { "url": "https://www.drushim.co.il/jobs/cat6/" },
    { "url": "https://www.drushim.co.il/jobs/area/21-22/" }
  ],
  "maxItems": 100
}
```

Overlapping results are emitted only once.

### How to extract exact Drushim vacancies

Use `jobUrls` when you already know the vacancies to collect.

```json
{
  "jobUrls": [
    { "url": "https://www.drushim.co.il/job/37827065/8dbaf2f8/" }
  ],
  "maxItems": 1
}
```

Exact URL mode extracts the public detail page and is useful for enrichment pipelines, saved-job lists, and webhook-driven workflows.

Only URLs on `drushim.co.il` are accepted.

### Input reference

| Input | Type | Required | Description |
|---|---|---:|---|
| `keywords` | string array | No\* | Hebrew or English search terms |
| `searchUrls` | request list | No\* | Public Drushim search/category/area URLs |
| `jobUrls` | request list | No\* | Public Drushim job detail URLs |
| `categoryIds` | string array | No | Category IDs for keyword searches |
| `regionIds` | string array | No | Region IDs for keyword searches |
| `experienceIds` | string array | No | Experience filter IDs |
| `scopeIds` | string array | No | Employment-scope filter IDs |
| `maxItems` | integer | No | Maximum unique jobs; defaults to 25 |

\*Provide at least one keyword, search URL, or job URL.

Filters apply to keyword searches. Filters already encoded in a `searchUrl` are preserved from that URL.

### Output example

```json
{
  "jobId": 37579533,
  "listingId": 29833350,
  "url": "https://www.drushim.co.il/job/37579533/1bb1bf0d/",
  "title": "Senior Java Developer -Yokneam",
  "employer": "CodeValue",
  "locations": ["יקנעם עילית"],
  "experience": "5-6 שנים",
  "employmentTypes": ["משרה מלאה"],
  "categories": ["הייטק-תוכנה"],
  "subcategories": ["JAVA"],
  "description": "Full public vacancy text…",
  "requirements": "Full public requirements…",
  "applyUrl": "https://www.drushim.co.il/sendcv.aspx?jobcode=37579533",
  "allowsNoCv": false,
  "isExpired": false,
  "sourceSearchUrl": "https://www.drushim.co.il/jobs/search/Java/",
  "scrapedAt": "2026-07-23T06:03:18.722Z"
}
```

The exact fields depend on what the employer publishes.

### How much does it cost to scrape Drushim jobs?

This Actor uses pay-per-event pricing:

- one small start charge per run;
- one result charge for each unique job saved to the dataset;
- automatic tier discounts based on your Apify plan.

The Apify Console shows the active price before a run begins.

Use `maxItems` to cap both output volume and result charges.

Because the Actor uses direct HTTP rather than a browser, runs are designed to remain fast and compute-efficient.

### Scheduling a Drushim job monitor

Apify schedules can run the Actor hourly, daily, or weekly.

A practical monitor workflow is:

1. Save one keyword or filtered URL input.
2. Choose a schedule matching the hiring signal you need.
3. Use `jobId` as the stable key.
4. Compare the new dataset with your previous export.
5. Send unseen jobs to your CRM, ATS, spreadsheet, or alert channel.

For fresher records, schedule smaller runs more frequently rather than one unbounded crawl.

### Export formats and integrations

Dataset results can be exported as JSON, CSV, Excel, XML, HTML, or RSS.

Common integrations include:

- **Google Sheets:** maintain a shared vacancy tracker.
- **Airtable:** build a recruiter review queue.
- **Make or Zapier:** route each new job into automated workflows.
- **Slack or email:** alert a team when matching roles appear.
- **CRM:** create employer hiring-signal activities.
- **ATS:** enrich candidate-matching or vacancy-ingestion pipelines.
- **Data warehouse:** analyze demand by category, city, or employer.

Use Apify webhooks to trigger downstream processing as soon as a run finishes.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/drushim-il-jobs-scraper').call({
  keywords: ['Java'],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Keep your Apify token in an environment variable rather than source code.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/drushim-il-jobs-scraper').call(run_input={
    'keywords': ['נהג'],
    'regionIds': ['1'],
    'maxItems': 25,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['jobId'], item['title'])
```

The Python client waits for completion and then reads the run dataset.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~drushim-il-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["Java"],"maxItems":10}'
```

The response includes the run ID and storage IDs.

Poll the run endpoint or use a webhook before reading the final dataset.

### Use with Apify MCP

Connect the Actor through the actor-scoped endpoint:

`https://mcp.apify.com?tools=automation-lab/drushim-il-jobs-scraper`

#### Claude Code

```bash
claude mcp add --transport http apify-drushim "https://mcp.apify.com?tools=automation-lab/drushim-il-jobs-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this HTTP MCP server in the Claude Desktop, Cursor, or VS Code MCP configuration and provide your Apify authorization when prompted:

```json
{
  "mcpServers": {
    "apify-drushim": {
      "url": "https://mcp.apify.com?tools=automation-lab/drushim-il-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Find the newest Java jobs on Drushim and summarize required experience.”
- “Extract 20 jobs from this Drushim category URL and group them by employer.”
- “Monitor Drushim vacancies mentioning Kubernetes and list new employers.”

### Tips for reliable results

- Start with 10–25 jobs while validating a new filter.
- Use Hebrew keywords when you need the broadest local-language coverage.
- Use exact job URLs for deterministic enrichment.
- Avoid adding the same search in many equivalent forms.
- Use `jobId`, not title, as your deduplication key.
- Treat salary as optional; many employers do not publish it.
- Schedule recurring runs if freshness matters.
- Preserve `sourceSearchUrl` when auditing why a record matched.

The Actor fails clearly if every supplied input yields no extractable jobs.

### Troubleshooting

#### Why did my run return fewer jobs than `maxItems`?

`maxItems` is a ceiling, not a guaranteed count. The source may contain fewer matching vacancies, and overlapping inputs are deduplicated by `jobId`.

#### Why is salary missing?

Drushim does not publish compensation for every vacancy. Optional salary fields are omitted rather than guessed.

#### Why was my URL rejected?

The Actor accepts public Drushim search and job paths only. Check that the hostname is `www.drushim.co.il` and that the URL is not an employer login, application form, or unrelated page.

#### Why do some jobs list several regions?

Employers can advertise one vacancy across multiple areas. The `addresses` field contains more precise city coordinates when available.

### Data quality and limitations

Output reflects public information available at run time.

Employers control vacancy text, location breadth, salary disclosure, and category assignments.

The Actor does not infer missing compensation, translate Hebrew, verify employer claims, submit applications, or bypass private account features.

A source redesign can temporarily affect extraction. Structured IDs and fail-closed behavior help reveal such changes instead of returning empty “successful” runs.

### Is it legal to scrape Drushim.co.il?

The Actor accesses publicly visible job advertisements without logging in.

Your use must still comply with applicable laws, the source website’s terms, privacy obligations, copyright rules, and your contractual responsibilities.

Do not use the output for unlawful discrimination, spam, harassment, or collection of unnecessary personal data.

If your use case affects individuals, consult qualified legal counsel and apply suitable retention and access controls.

### Related scrapers

Combine this Actor with other automation-lab tools for broader workflows:

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for multi-source job coverage
- [Company Website Contacts Scraper](https://apify.com/automation-lab/company-website-contacts-scraper) for employer enrichment
- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) for public company research

Choose only the sources and enrichment steps relevant to your lawful workflow.

### FAQ

#### Does it support Hebrew keywords?

Yes. Hebrew and English search terms are preserved as Unicode.

#### Can I combine keywords and URLs?

Yes. Results from all inputs are merged and deduplicated.

#### Does it scrape full descriptions?

Yes. The public search data includes full descriptions and requirements for matching jobs.

#### Can it apply for jobs?

No. It returns the public application URL but does not submit forms or CVs.

#### Can I run it on a schedule?

Yes. Use Apify schedules and compare stable `jobId` values between runs.

#### Does it require a proxy or Drushim account?

No account is required. The current extraction route uses anonymous public HTTP data.

#### Can I export to CSV or Excel?

Yes. Use the Dataset export controls or API endpoints.

#### Are duplicate jobs charged twice?

Not within one run. The Actor deduplicates by job ID before saving and charging the result event.

### Support

For a reproducible issue, include:

- the Actor run URL;
- the input used;
- one expected Drushim job or search URL;
- a short description of expected versus actual output.

Do not include private credentials, CVs, or unrelated personal information.

# Actor input Schema

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

Hebrew or English job-search terms, for example Java, נהג, or מנהל מוצר.

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

Drushim category, area, subcategory, or keyword search pages. Existing URL filters are preserved.

## `jobUrls` (type: `array`):

Optional public Drushim job detail URLs to extract directly.

## `categoryIds` (type: `array`):

Optional Drushim category IDs applied to keyword searches, such as 6 for software.

## `regionIds` (type: `array`):

Optional Drushim region IDs applied to keyword searches.

## `experienceIds` (type: `array`):

Optional Drushim experience-level IDs applied to keyword searches.

## `scopeIds` (type: `array`):

Optional Drushim employment-scope IDs applied to keyword searches.

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

Stop after this many unique job records across all inputs.

## Actor input object example

```json
{
  "keywords": [
    "Java"
  ],
  "searchUrls": [
    {
      "url": "https://www.drushim.co.il/jobs/search/Java/"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Full-detail job rows with employer, location, experience, description, requirements, salary, and application data.

# 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": [
        "Java"
    ],
    "searchUrls": [
        {
            "url": "https://www.drushim.co.il/jobs/search/Java/"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/drushim-il-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": ["Java"],
    "searchUrls": [{ "url": "https://www.drushim.co.il/jobs/search/Java/" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/drushim-il-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": [
    "Java"
  ],
  "searchUrls": [
    {
      "url": "https://www.drushim.co.il/jobs/search/Java/"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/drushim-il-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drushim.co.il Jobs Scraper",
        "description": "Extract public Israeli job listings from Drushim by keyword, filtered search page, category, region, or exact vacancy URL.",
        "version": "0.1",
        "x-build-id": "CoN7VISqvQG8tVxj0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~drushim-il-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-drushim-il-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/automation-lab~drushim-il-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-drushim-il-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/automation-lab~drushim-il-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-drushim-il-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",
                "properties": {
                    "keywords": {
                        "title": "🔎 Job keywords",
                        "type": "array",
                        "description": "Hebrew or English job-search terms, for example Java, נהג, or מנהל מוצר.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Drushim search URLs",
                        "type": "array",
                        "description": "Drushim category, area, subcategory, or keyword search pages. Existing URL filters are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "jobUrls": {
                        "title": "🎯 Exact job URLs",
                        "type": "array",
                        "description": "Optional public Drushim job detail URLs to extract directly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Optional Drushim category IDs applied to keyword searches, such as 6 for software.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regionIds": {
                        "title": "Region IDs",
                        "type": "array",
                        "description": "Optional Drushim region IDs applied to keyword searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "experienceIds": {
                        "title": "Experience IDs",
                        "type": "array",
                        "description": "Optional Drushim experience-level IDs applied to keyword searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scopeIds": {
                        "title": "Employment scope IDs",
                        "type": "array",
                        "description": "Optional Drushim employment-scope IDs applied to keyword searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique job records across all inputs.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
