# AllJobs Israel Job Listings Scraper (`automation-lab/alljobs-israel-job-listings-scraper`) Actor

Search and export public AllJobs.co.il vacancies with job IDs, employers, locations, posting context, descriptions, requirements, categories, and canonical URLs.

- **URL**: https://apify.com/automation-lab/alljobs-israel-job-listings-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

from $0.87 / 1,000 item extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AllJobs Israel Job Listings Scraper

Search and export **AllJobs Israel jobs** as structured vacancy records for recruiting, sourcing, and labor-market analysis.

The Actor reads public AllJobs.co.il search and job pages and returns stable job IDs, titles, employers, locations, work arrangements, posting context, descriptions, requirements, categories when exposed, and canonical URLs.

No AllJobs account is required.

### What can you do with this AllJobs scraper?

- Build a current feed of public Israeli vacancies.
- Search recent listings by text found in titles, employers, descriptions, or requirements.
- Export jobs for one AllJobs city, region, position, or job type.
- Fetch one known public job URL.
- Schedule repeat runs and compare records by `jobId`.
- Send results to Google Sheets, a database, an ATS staging table, or a BI pipeline.

This Actor extracts public vacancy data. It does not apply for jobs, contact employers, or access candidate information.

### Who is it for?

**Recruiters and sourcers** can refresh role-specific vacancy feeds and identify active employers.

**Talent intelligence teams** can monitor hiring activity by city or AllJobs category.

**Labor-market analysts** can collect normalized snapshots for aggregate research.

**Data engineers** can consume stable JSON records through datasets, webhooks, and the Apify API.

**Job-search product teams** can prototype lawful discovery workflows using public listing metadata.

### Data extracted from every vacancy

| Field | Meaning |
| --- | --- |
| `jobId` | Stable AllJobs vacancy ID |
| `title` | Displayed job title |
| `employer` | Public employer name, when displayed |
| `employerId` | AllJobs employer ID, when exposed |
| `employerUrl` | Public employer page |
| `locations` | All displayed job locations |
| `location` | Joined location summary |
| `employmentTypes` | Work arrangements and audience tags |
| `benefits` | Additional conditions shown on the card |
| `postingContext` | Source-relative age such as “2 hours ago” |
| `description` | Public role description |
| `requirements` | Separately extracted requirements section |
| `categories` | Category labels exposed by a job-detail page |
| `categoryIds` | Position/category IDs exposed in source links |
| `sourcePage` | Search-results page number |
| `url` | Canonical AllJobs job URL |
| `scrapedAt` | UTC extraction timestamp |

Nullable fields are returned as `null` or an empty array when AllJobs does not expose them.

### Why use this Actor?

AllJobs pages are Hebrew-first and contain useful vacancy details inside server-rendered job cards.

The Actor parses those cards directly, so a normal search page can yield descriptions and requirements without opening every job in a browser.

That provides:

- low runtime overhead;
- stable source IDs for deduplication;
- explicit bounds through `maxItems` and `maxPages`;
- consistent text filters for search URLs and detail URLs;
- typed output ready for JSON, CSV, Excel, XML, or RSS export.

### Getting started

1. Open the Actor in Apify Console.
2. Keep the prefilled Tel Aviv URL or remove it to scan the newest national vacancies.
3. Optionally add `query`, `location`, or numeric AllJobs filter IDs.
4. Set `maxItems` to the number of matching jobs you need.
5. Click **Start**.
6. Open the **Dataset** tab to preview or download records.
7. Save the input as a Task if you want to schedule the same feed.

A useful broad run is:

```json
{
  "query": "מכירות",
  "maxItems": 10,
  "maxPages": 3
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | Tel Aviv search URL in prefill | Public AllJobs search-results or job-detail URLs |
| `query` | string | — | Text required in title, employer, description, or requirements |
| `location` | string | — | Text required in one displayed location |
| `positionId` | integer | — | Positive AllJobs position/category ID |
| `cityId` | integer | — | Positive AllJobs city ID |
| `regionId` | integer | — | Positive AllJobs region ID |
| `jobTypeId` | integer | — | Positive AllJobs job-type ID |
| `maxItems` | integer | `20` | Maximum unique matching jobs, up to 1,000 |
| `maxPages` | integer | `10` | Maximum pages per search seed, up to 100 |
| `maxRequestRetries` | integer | `2` | Retries for transient request failures, from 0 to 5 |

You can copy numeric filter values from a public AllJobs search URL.

For example, `city=779` represents the source's Tel Aviv city selection.

### Search URL and explicit job URL modes

A search URL has this shape:

```text
https://www.alljobs.co.il/SearchResultsGuest.aspx?page=1&position=&type=&city=779&region=
```

The Actor preserves its source filters and changes only the page number while paginating.

A detail URL has this shape:

```text
https://www.alljobs.co.il/Search/UploadSingle.aspx?JobID=8123456
```

Detail mode returns only the requested current job, even when the page includes related vacancies.

If `query` or `location` is also supplied, that same filter is applied before the explicit job is saved.

### Example output

```json
{
  "jobId": "8123456",
  "title": "מפתח/ת תוכנה",
  "employer": "חברה לדוגמה",
  "employerId": "123456",
  "employerUrl": "https://www.alljobs.co.il/Employer/HP/Default.aspx?cid=123456",
  "locations": ["תל אביב יפו"],
  "location": "תל אביב יפו",
  "employmentTypes": ["משרה מלאה"],
  "benefits": [],
  "postingContext": "לפני 2 שעות",
  "description": "תיאור תפקיד לדוגמה.",
  "requirements": "ניסיון קודם בתחום.",
  "categories": ["תוכנה"],
  "categoryIds": ["123"],
  "sourcePage": 1,
  "url": "https://www.alljobs.co.il/Search/UploadSingle.aspx?JobID=8123456",
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

The README example is anonymized. Live output contains the public source text available at run time.

### How pagination and limits work

Search pages are processed sequentially.

The Actor deduplicates records by `jobId`, applies text filters, and stops as soon as `maxItems` accepted records have been saved.

A selective text query may require a larger `maxPages` because filtering happens against the full normalized vacancy text.

The run also stops when the source returns no job cards or a short final page.

### How much does it cost to extract AllJobs Israel jobs?

The Actor uses pay-per-event pricing:

- **$0.00005** once per run;
- **$0.001448 per saved job** on the Bronze plan;
- lower item prices on higher plans, down to **$0.0008688 per job** on Gold, Platinum, and Diamond.

Example Bronze Actor charges:

| Saved jobs | Estimated Actor charge |
| ---: | ---: |
| 10 | $0.01453 |
| 100 | $0.14485 |
| 1,000 | $1.44805 |

Only unique records written to the default dataset incur the `item` charge.

Rejected text matches, duplicate job IDs, empty pages, and failed records are not charged as items.

Apify plan and platform-usage terms may also apply; check Console for the active price before a large run.

### Recurring recruiting feed workflow

1. Choose a source category, city, or search URL.
2. Run once and retain `jobId`, `postingContext`, and `scrapedAt`.
3. Save the input as an Apify Task.
4. Add a daily or weekly schedule.
5. Send the dataset to your destination through an integration or webhook.
6. Compare current `jobId` values with the previous snapshot.
7. Treat missing IDs as candidates for manual status verification, not guaranteed deletions.

The Actor does not maintain historical state or classify changes itself.

### Export to Google Sheets or another pipeline

After a run, open the dataset and select JSON, CSV, Excel, XML, or RSS.

For a recurring pipeline, connect the Task to:

- Google Sheets;
- Make;
- Zapier;
- a webhook;
- an Apify integration;
- your own dataset API consumer.

Use `jobId` as the source identity and `scrapedAt` as the observation time.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~alljobs-israel-job-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"positionId":366,"maxItems":20,"maxPages":2}'
```

To wait for results directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~alljobs-israel-job-listings-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"מכירות","maxItems":10,"maxPages":3}'
```

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/alljobs-israel-job-listings-scraper').call({
  cityId: 779,
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(({ jobId, title, employer }) => ({ jobId, title, employer })));
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/alljobs-israel-job-listings-scraper').call(
    run_input={'location': 'תל אביב', 'maxItems': 25, 'maxPages': 5}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(item['jobId'], item['title'], item.get('employer'))
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/alljobs-israel-job-listings-scraper"
```

#### Claude Desktop

Add this server entry to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/alljobs-israel-job-listings-scraper"
    }
  }
}
```

#### Cursor

Add the same `apify` server URL in **Cursor Settings → MCP** and enable it for the workspace.

#### VS Code

Add the same `apify` server URL through your VS Code MCP extension or workspace MCP configuration.

Example prompts:

- “Find up to 20 current AllJobs insurance jobs and summarize employers by location.”
- “Run the Tel Aviv AllJobs feed and return job ID, title, employer, and requirements.”
- “Export current AllJobs sales vacancies as a CSV-ready table.”

### Reliability and retry behavior

The Actor validates the hostname and URL path before making a request.

Transient network errors, rate limits, and temporary server errors receive bounded exponential-backoff retries.

A missing job, unsupported URL, challenge page, or unrecognized source shape fails explicitly instead of silently returning a successful empty scrape.

No automatic residential proxy or browser fallback is enabled, which keeps runs predictable and inexpensive.

### Limits and source behavior

- AllJobs content is primarily Hebrew.
- `postingContext` is source-relative text, not a fabricated timestamp.
- Search cards may expose category IDs without category names.
- Detail pages usually expose richer category labels.
- Employers can be anonymous, so employer fields may be null.
- A job can expire between discovery and extraction.
- Source markup and public availability can change without notice.
- Text filtering is literal, case-insensitive matching; it is not semantic search.
- The Actor does not translate, rank, enrich, or apply to jobs.

### Responsible use and legality

Use the Actor only for legitimate purposes and public information you are permitted to process.

Follow AllJobs.co.il terms, robots guidance, applicable database rights, copyright rules, privacy law, and employment regulations.

Avoid republishing full descriptions without a lawful basis.

Do not use job data for unlawful discrimination, spam, deceptive recruitment, or decisions that require human review.

You are responsible for your input, retention policy, downstream processing, and compliance obligations.

### Troubleshooting

#### Why did my keyword search return fewer jobs than `maxItems`?

The keyword is matched against jobs found within `maxPages`. Increase `maxPages`, simplify the query, or use a source position/city URL.

#### Why is an employer null?

Some vacancies do not display an employer name. The Actor preserves that absence rather than inventing a value.

#### Why did a detail URL fail?

The job may have expired, the `JobID` may be missing, or the URL may not be a supported public AllJobs path.

#### Why are category names empty?

Search cards often expose only position IDs. Use a detail URL when named categories are required for one vacancy.

### FAQ

#### Does this Actor require an AllJobs login?

No. It extracts public guest search and job pages.

#### Can I search in Hebrew?

Yes. Hebrew text is the normal choice for `query` and `location`.

#### Can I scrape every AllJobs job?

The Actor supports up to 1,000 accepted jobs and 100 pages per search seed. Choose a bounded scope that is necessary for your use case.

#### Are results translated to English?

No. Source text is preserved.

#### Can I schedule monitoring?

Yes. Save an input as a Task and schedule it. Compare `jobId` values downstream; the Actor itself does not send alerts or store prior snapshots.

#### Is the output available as CSV or Excel?

Yes. Apify datasets can be downloaded in both formats, along with JSON, XML, and RSS.

### Related automation-lab Actors

For wider geographic recruiting research, explore other job-listing Actors from the `automation-lab` Apify portfolio.

Choose a source-specific Actor when you need that board's native fields, and normalize records downstream using stable source IDs and canonical URLs.

### Support

If a run fails, include the public input shape, run ID, expected scope, and whether the affected URL is a search or detail page.

Do not include credentials, candidate data, or other private information in a support report.

# Actor input Schema

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

Optional public AllJobs SearchResultsGuest.aspx or Search/UploadSingle.aspx URLs. Other hosts and paths are rejected.

## `query` (type: `string`):

Optional Hebrew or English text required in the title, employer, description, or requirements. The Actor scans up to maxPages of the selected AllJobs feed.

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

Optional Hebrew location text required in a listing location, for example תל אביב.

## `positionId` (type: `integer`):

Optional positive numeric position value copied from an AllJobs search URL.

## `cityId` (type: `integer`):

Optional positive numeric city value copied from an AllJobs search URL.

## `regionId` (type: `integer`):

Optional positive numeric region value copied from an AllJobs search URL.

## `jobTypeId` (type: `integer`):

Optional positive numeric type value copied from an AllJobs search URL.

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

Maximum number of unique matching vacancy records to save.

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

Maximum result pages per search URL. Raise this when a text filter is selective.

## `maxRequestRetries` (type: `integer`):

Retries for transient network, rate-limit, and server errors.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.alljobs.co.il/SearchResultsGuest.aspx?page=1&position=&type=&city=779&region="
    }
  ],
  "maxItems": 20,
  "maxPages": 10,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Dataset containing all matching job records.

# 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": [
        {
            "url": "https://www.alljobs.co.il/SearchResultsGuest.aspx?page=1&position=&type=&city=779&region="
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/alljobs-israel-job-listings-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 = { "startUrls": [{ "url": "https://www.alljobs.co.il/SearchResultsGuest.aspx?page=1&position=&type=&city=779&region=" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/alljobs-israel-job-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.alljobs.co.il/SearchResultsGuest.aspx?page=1&position=&type=&city=779&region="
    }
  ]
}' |
apify call automation-lab/alljobs-israel-job-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/alljobs-israel-job-listings-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/QjTepiCqa3KNUuTmw/builds/zsygMqAvUdWIRfBOz/openapi.json