# IrishJobs Ireland Vacancy Listings Scraper (`automation-lab/irishjobs-vacancy-listings-scraper`) Actor

Export public IrishJobs Ireland vacancy listings with job IDs, employers, locations, advertised salary text and posting timestamps. Use keyword/location searches or IrishJobs search URLs for recurring recruitment snapshots.

- **URL**: https://apify.com/automation-lab/irishjobs-vacancy-listings-scraper.md
- **Developed by:** [Automation Lab](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.71 / 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?

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

## IrishJobs Ireland Vacancy Listings Scraper

Export **IrishJobs Ireland** vacancy listings as a clean recruitment snapshot. Give the Actor a keyword and optional location, or paste public IrishJobs.ie search URLs. Get job IDs, titles, employers, locations, advertised salary text, posting timestamps and vacancy links in JSON, CSV or Excel through Apify's dataset exports.

This is a listing-only product for recruiters, recruitment analysts and data teams who need repeatable observations of current vacancies. It does not collect applicant records, infer salaries or open individual job detail pages.

### Why use this Actor?

- Join snapshots using stable source job IDs rather than job titles.
- Preserve salary wording, including “Not Disclosed”, without inventing ranges.
- Keep the search URL and observation time on every row for provenance.
- Deduplicate jobs within a run, including overlapping search pages.
- Use a lightweight public search route without supplying cookies, accounts or proxy credentials.

Scheduling and downstream comparison are possible with Apify tools. The Actor itself does not maintain historical state, detect changes or send alerts.

### Who is it for?

Recruiters can refresh a shortlist of advertised roles. Labor-market analysts can compare vacancy snapshots over time. Data engineers can load the default dataset into a spreadsheet, warehouse or recruiting research pipeline.

Search results follow IrishJobs' own matching and ranking, including related roles and nearby locations. A keyword is not an exact-phrase filter and is not guaranteed to appear in every title.

### Getting started

1. Keep the default software-developer search, or enter your keyword.
2. Optionally enter a location such as Dublin with the keyword.
3. Set a small `maxItems` value for your first run.
4. Run the Actor and inspect **Output → Vacancy records**.
5. Export the dataset as JSON, CSV or Excel.

Example keyword input:

```json
{
  "keyword": "software developer",
  "location": "Dublin",
  "maxItems": 25,
  "maxPages": 2
}
```

Alternatively, preserve a search you configured on the website:

```json
{
  "startUrls": [{"url": "https://www.irishjobs.ie/jobs/software-developer"}],
  "maxItems": 30,
  "maxPages": 2
}
```

Use **either** URL input **or** keyword/location input, never both. Only HTTPS search URLs on `www.irishjobs.ie` under `/jobs` are supported. Job-detail URLs, other domains and unsupported input fields fail validation.

### Inputs and search behavior

| Input | Default | Meaning |
|---|---|---|
| `startUrls` | Not set | 1–10 search URL objects; source query filters and starting page are preserved. |
| `keyword` | Software developer when no search is supplied | Trimmed search text converted to an IrishJobs URL slug; upstream matching, not local substring filtering. |
| `location` | Not set | Upstream location search; requires keyword. |
| `maxItems` | 20 | Global cap of 1–250 unique saved jobs across all searches. Zero is invalid. |
| `maxPages` | 2 | Global cap of 1–10 successful search pages, including the initial pages. |
| `maxRequestRetries` | 1 | 0–2 additional attempts per page for transient HTTP/network failures. |

Both caps apply together. Ten pages normally cover up to 250 source rows, but fewer unique jobs may be returned. Repeated records consume a page without producing duplicate output. Search URLs run in the supplied order; an early search can consume the entire limit before later searches begin.

There is no unlimited mode. Source exhaustion, billing limits and the run timeout can stop collection before the requested cap. Apify schedules can repeat a saved input, but each run is an independent snapshot.

### Extracted data

| Field | Meaning |
|---|---|
| `jobId` | Stable numeric source ID stored as text. |
| `title` | Public vacancy title. |
| `employer` | Source employer or advertiser name, nullable. |
| `location` | Source location text, nullable; no independent geocoding. |
| `salaryText` | Advertised wording, including “Not Disclosed”, or null when absent. |
| `postedText` | Relative posted wording only if supplied; normally null on this route. |
| `postedAt` | Source `datePosted` timestamp, nullable and unmodified. |
| `jobUrl` | Public vacancy URL without query or fragment. |
| `sourceSearchUrl` | Search URL that supplied the row, including pagination. |
| `fetchedAt` | UTC observation timestamp. |

The API currently supplies posting timestamps rather than relative “days ago” text. The Actor does not calculate a replacement for missing posted text. Salary fields are not estimates or verified compensation offers.

### Output example

A representative public search record has this shape; the observation timestamp varies:

```json
{
  "jobId": "108110284",
  "title": "Full Stack Software Developer Lead",
  "employer": "PM Group",
  "location": "Dublin, County Dublin",
  "salaryText": "€ Not Disclosed",
  "postedText": null,
  "postedAt": "2026-10-07T20:21:48.9Z",
  "jobUrl": "https://www.irishjobs.ie/job/full-stack-lead/pm-group-job108110284",
  "sourceSearchUrl": "https://www.irishjobs.ie/jobs/software-developer",
  "fetchedAt": "2026-10-16T10:00:00.000Z"
}
```

All primary records go to the run's default dataset. No global shared dataset is reused, and no raw HTML or debugging objects are emitted as results.

### How much does it cost to export IrishJobs vacancy listings?

The Actor charges once for `start`, then once per unique vacancy saved through `item`. Duplicate records, unsuccessful pages and empty pages have no item charge. A valid search with no results still has a start charge.

The run start costs **$0.001**. Per-vacancy prices are FREE **$0.001357**, BRONZE **$0.00118**, SILVER **$0.0009204**, and GOLD / PLATINUM / DIAMOND **$0.000708**. These prices include the Actor's required infrastructure; there is no undisclosed third-party fee.

| Unique vacancies | BRONZE estimated total including start |
|---|---:|
| 1 | $0.00218 |
| 25 | $0.03050 |
| 100 | $0.11900 |

Spend tiers depend on qualifying aggregate monthly Apify Store spend, not volume in this Actor alone. Other tiers can have different unit prices. The pricing tab is authoritative; estimates are not guaranteed invoices. No additional source account, paid source API, browser or residential-proxy subscription is required. There is no separate detail-page charge because details are not fetched.

### Limits and failure behavior

This Actor exports current public listings only. It does not promise full descriptions, application endpoints, employer profiles, contact emails, historical completeness, private applicant data, inferred salaries or other job boards.

The public source can change, rate-limit requests or return a challenge. Challenge/invalid JSON and permanent HTTP failures are errors, not valid empty searches. Only transient network errors and selected temporary HTTP failures receive bounded backoff retries. No hidden browser or proxy fallback is enabled.

If a later page fails, the run fails and previously saved rows are **partial**, not a complete successful snapshot. Repeated pagination URLs or pages containing only already-seen jobs are reported rather than silently looping. Source order and job availability can change while pagination is running.

### Integrations and recurring snapshots

- **Google Sheets or Excel:** export CSV and compare `jobId` across observation dates.
- **n8n, Make or Zapier:** start a run, wait for its terminal status, then read the returned default dataset.
- **Warehouse pipelines:** load dataset JSON and retain `sourceSearchUrl` and `fetchedAt` as provenance columns.
- **Apify schedules:** repeat the same search daily and compare downstream. A missing job in a capped snapshot does not prove a vacancy closed.

The Actor does not notify employers, submit applications, contact candidates or write to recruitment systems.

### API usage

Keep your Apify token private. The following examples start a run; its response is run metadata, not the vacancy rows. Wait for success and then read `defaultDatasetId`.

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~irishjobs-vacancy-listings-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"software developer","maxItems":25,"maxPages":2}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/irishjobs-vacancy-listings-scraper')
  .call({ keyword: 'software developer', maxItems: 25, maxPages: 2 });
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/irishjobs-vacancy-listings-scraper').call(
    run_input={'keyword': 'software developer', 'maxItems': 25, 'maxPages': 2})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=25).items)
```

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

For Claude Code:

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

For Claude Desktop, Cursor and VS Code, adapt the HTTP server configuration to the client's supported format and authenticate through its Apify setup:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/irishjobs-vacancy-listings-scraper"
    }
  }
}
```

Example prompt: “Export 25 software-developer vacancies from IrishJobs Ireland and show titles, employers and salary wording.” Another: “Run a Dublin vacancy snapshot and give me the dataset link for downstream comparison.”

Discover the scoped tool names and argument schemas with `tools/list`; Actor selection also adds run/data tools and does not expose exactly one tool. For an authorized run, start once and retain its run ID and storage IDs. `call-actor` waits at most 45 seconds (default 30); configure client timeout above the chosen server wait plus transport margin.

If still running, check that same run with bounded 2/4/8-second backoff capped at 10 seconds, with a 120-second total deadline. After a client timeout recover the known run, never restart just to poll. At deadline report pending and its run ID. Terminal failures must be reported honestly, with any available rows labeled partial.

After success, fetch dataset items in pages of 20 using explicit offset, limit and only needed fields. Example consumer context budget: at most 100 source rows and 64 KiB serialized UTF-8 content, whichever comes first. Enforce bytes host-side before model injection; omit or summarize oversized rows with disclosure. If your client cannot intercept responses, do not claim a hard byte guarantee. Report returned count, next offset and truncation; keep full exports outside model context. These are consumer limits, not reductions in Actor collection. No universal token-saving claim is made.

### Legality, responsible use and non-affiliation

Use public vacancy information responsibly, respect applicable source terms and privacy law, and assess your own intended downstream use. Public access does not grant unrestricted reuse rights. This independent tool is not affiliated with, endorsed by or certified by IrishJobs or its operator. Source names are used descriptively, not as company branding.

Apify's standard terms apply. No custom end-user contract is added. Do not use this product to gather applicant records or profile private individuals.

### Privacy, retention and AI

The Actor processes public job advertisements and supplied search parameters. It does not use AI at runtime or send job data to an AI provider. An original generated icon is a static build asset, not a runtime data recipient.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. Normal logs contain counts, statuses and bounded error messages rather than page bodies or credentials.

Apify stores input, dataset rows and run logs under your account's storage and retention settings. This Actor does not create an additional historical database or persist source cookies. Delete run datasets and key-value stores in Apify when no longer needed; deleting a run alone should not be assumed to delete all associated storage. Diagnostic retention is separate. Apify hosts execution/storage and the private diagnostic service receives scrubbed failures only.

### FAQ and troubleshooting

**Why is salary missing or “Not Disclosed”?** The source did not advertise a salary. No value is inferred or filled from another website.

**Why is `postedText` null?** This route supplies `postedAt`; it normally has no relative wording. Use the source timestamp for analysis.

**Why fewer records than requested?** Check maxPages, upstream availability, deduplication, billing limits and timeout. Limits are caps, not promised counts.

**Can I use a job-detail URL?** No. Paste a `/jobs/` search URL or use keyword/location. This Actor intentionally does not fetch full descriptions.

**Why did a run fail after saving rows?** An upstream error or pagination inconsistency occurred. Retain the run ID and treat those rows as partial; do not mistake a challenge page for no vacancies.

**Can it detect new or closed roles?** Not natively. Schedule snapshots and compare IDs downstream. Capped snapshots are not complete closure evidence.

### Related Actors and support

For a separate country-specific recruiting workflow, see [jobs.ch Switzerland Job Listings Scraper](https://apify.com/automation-lab/jobs-ch-listings-scraper) and [Karriere.at Austria Job Listings Scraper](https://apify.com/automation-lab/karriere-at-austria-job-listings-scraper). Their source coverage is separate and is not included in this Actor.

For help, open an issue on this Actor's Apify page with the run URL, sanitized input and expected versus observed behavior. Do not post credentials or private applicant data.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/irishjobs-vacancy-listings-scraper/changelog.md

# Actor input Schema

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

1–10 HTTPS www.irishjobs.ie/jobs/ search URL objects. Preserves URL filters and starting offset. Cannot combine with keyword or location. Detail URLs and other hosts are rejected. Duplicate URLs and job IDs are removed within this run.

## `keyword` (type: `string`):

IrishJobs upstream search terms, trimmed and converted to a URL slug; not a local exact-phrase filter. Source ranking may return related titles. Cannot combine with startUrls. Defaults to software developer when no search is supplied.

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

IrishJobs location slug, for example Dublin or Cork. Requires keyword and cannot combine with startUrls. Filtering is performed by IrishJobs, not by local substring matching; nearby results follow the site's behavior.

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

Global cap on unique saved jobs across all search URLs, after job-ID deduplication. 1–250, default 20; zero is invalid. Stops when this cap, maxPages, source exhaustion, billing limit or timeout is reached. Does not guarantee this many results.

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

Global cap on successful search pages across all URLs, including their first pages; 1–10, default 2. Pages usually contain 25 jobs. Repeated jobs still consume a page; no unlimited setting. Increase with maxItems for larger snapshots.

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

Additional attempts per page for network timeouts/resets and HTTP 408/425/429/5xx. 0–2, default 1. Challenge, malformed data and permanent HTTP errors fail immediately. No browser or residential proxy fallback.

## Actor input object example

```json
{
  "maxItems": 20,
  "maxPages": 2,
  "maxRequestRetries": 1
}
```

# Actor output Schema

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

Export this run's job records as JSON or CSV.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/irishjobs-vacancy-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/irishjobs-vacancy-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 '{}' |
apify call automation-lab/irishjobs-vacancy-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/irishjobs-vacancy-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/df9KuerRbRD4AdLO8/builds/hStMWVVUTtXK6Ze0h/openapi.json