# Jobs.ie Scraper (`parsebird/jobs-ie-scraper`) Actor

Scrape job listings from Jobs.ie (Ireland) by keyword, location, contract type, and salary. Get titles, employers, locations, salaries, full descriptions, and incremental change monitoring. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/parsebird/jobs-ie-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 job scrapeds

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

### Jobs.ie Scraper

Scrape job listings from **[Jobs.ie](https://www.jobs.ie)** — Ireland's job board — into clean, structured JSON. The Jobs.ie Scraper pulls the job title, employer, location, salary, contract type, posting date, description, and company details for any keyword and county search, with no login and no Jobs.ie API.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search Jobs.ie by keyword, county, contract type, advertiser type, salary, and posting age — or paste a Jobs.ie search URL — and get a structured record per vacancy, plus optional full descriptions and incremental change monitoring across scheduled runs.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Actor: parsebird/jobs-ie-scraper (Apify). Scrapes job listings from jobs.ie (Ireland). Call with ApifyClient.
Input JSON fields:
  query: string — job keyword, e.g. "software developer", "accountant" (required unless startUrls set)
  location: string — Irish city, county, or province, e.g. "Dublin", "County Cork", "Munster"
  jobType: "any"|"permanent"|"contract"|"temporary"|"part-time"|"work-from-home" (default "any")
  sort: "relevance"|"date"|"salary_desc"|"salary_asc" (default "relevance")
  postedWithinDays: "0"|"1"|"3"|"7"|"14" (default "0" = any time)
  companyType: "any"|"agency"|"direct" (default "any")
  minSalary: int (EUR) + salaryPeriod: "annual"|"daily"|"hourly"
  radius: int — km around the location
  includeDetails: bool (default false) — open each job page for the full description, employment type, industry, geo-coordinates
  compact: bool (default false) — core fields only
  maxResults: int (default 50) — number of billed rows
  startUrls: string[] — jobs.ie search or single-job URLs; overrides query/filters
  incrementalMode: bool + stateKey: string — return only changed jobs since the last run
  proxyConfiguration: { "useApifyProxy": true }
Output: one dataset item per job — jobKey, title, company, location, url, datePosted, postedDaysAgo, salary,
  isSponsored, isHighlighted, companyId, companyUrl, companyLogoUrl, textSnippet, harmonisedId, partnership,
  publishFromDate, publishToDate, geo, query, scrapedAt, and with includeDetails: descriptionHtml, descriptionText,
  employmentType, validThrough, industry, directApply, locationDetail{city,country,lat,lng}. Incremental adds
  changeType, firstSeenAt, lastSeenAt, isRepost.
Example: { "query": "software developer", "location": "Dublin", "maxResults": 50 }
API: https://api.apify.com/v2/acts/parsebird~jobs-ie-scraper  ·  Token: https://console.apify.com/account/integrations
```

### What does Jobs.ie Scraper do?

[Jobs.ie](https://www.jobs.ie) is one of Ireland's largest job boards, carrying thousands of live vacancies from direct employers and recruitment agencies across every county. There is no public Jobs.ie API — this Jobs.ie scraper reads the public search and job-advert pages instead. It extracts:

- 💼 **Job** — title, contract type, description, and the direct advert URL.
- 🏢 **Employer** — company name, company page, logo, and whether the ad was posted by an agency or a direct employer.
- 📍 **Location** — town, county, and (with `includeDetails`) geo-coordinates and country.
- 💶 **Salary** — the advertised salary or range, when the employer discloses it.
- 📅 **Dates** — when the vacancy was published and when it expires.
- 🔖 **Identifiers** — the Jobs.ie job key and harmonised ID for deduplication.
- 📄 **Description** — the full job description as structured HTML and clean plain text (with `includeDetails`).

Common uses: Ireland recruitment-market research, building a jobs board or alert service, salary benchmarking, and monitoring hiring at specific employers or in specific counties.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| query | string | Yes\* | — | Job title, role, or skill to search for. \*Not required when `startUrls` is set. |
| location | string | No | — | Irish city, county, or province (`Dublin`, `County Cork`, `Munster`). |
| jobType | string | No | any | `permanent`, `contract`, `temporary`, `part-time`, or `work-from-home`. |
| sort | string | No | relevance | `relevance`, `date`, `salary_desc`, or `salary_asc`. |
| postedWithinDays | string | No | 0 | Limit to jobs posted in the last `1`, `3`, `7`, or `14` days. |
| companyType | string | No | any | `agency` (recruiter) or `direct` (direct employer). |
| minSalary | integer | No | 0 | Minimum salary in euro, paired with `salaryPeriod`. |
| salaryPeriod | string | No | annual | `annual`, `daily`, or `hourly`. |
| radius | integer | No | 0 | Search radius in km around the location. |
| includeDetails | boolean | No | false | Open each job page for the full description and extra fields. |
| compact | boolean | No | false | Return core fields only. |
| maxResults | integer | No | 50 | Maximum jobs to return (billed rows). |
| startUrls | array | No | — | Jobs.ie search or single-job URLs. Overrides `query` and filters. |
| incrementalMode | boolean | No | false | Return only jobs that changed since the last run with the same `stateKey`. |
| stateKey | string | No | default | Separates one watchlist or schedule from another. |
| proxyConfiguration | object | No | Apify Proxy | Proxy settings. Datacenter is enough; use Residential (IE) only on repeated blocks. |

#### Example inputs

Basic keyword search:

```json
{ "query": "software developer", "maxResults": 50 }
```

Filtered search — permanent, direct employers, in Dublin, paying at least €50k:

```json
{
  "query": "accountant",
  "location": "Dublin",
  "jobType": "permanent",
  "companyType": "direct",
  "minSalary": 50000,
  "salaryPeriod": "annual",
  "maxResults": 100
}
```

Incremental tracking — only emit jobs that changed since the previous run:

```json
{
  "query": "software developer",
  "maxResults": 200,
  "incrementalMode": true,
  "stateKey": "software-developer-tracker"
}
```

Compact output for an LLM or MCP data source:

```json
{ "query": "project manager", "compact": true, "maxResults": 50 }
```

### What data can you extract from Jobs.ie?

| Field | Description |
|-------|-------------|
| jobKey | Jobs.ie numeric job identifier |
| title | Job title |
| company | Employer or recruitment agency name |
| location | Town and county |
| salary | Advertised salary or range (when disclosed) |
| url | Direct link to the job advert |
| datePosted / postedDaysAgo | Publication date and age in days |
| publishFromDate / publishToDate | Advert live window |
| companyId / companyUrl / companyLogoUrl | Employer page and logo on Jobs.ie |
| isSponsored / isHighlighted / isTopJob | Promotion flags |
| textSnippet / textSnippetCleaned | Search-result summary, raw and cleaned |
| harmonisedId | Cross-listing harmonised identifier |
| partnership | Backfill / cross-post metadata |
| descriptionHtml / descriptionText | Full job description (with `includeDetails`) |
| employmentType / industry / validThrough / directApply | Structured job metadata (with `includeDetails`) |
| locationDetail | City, country, latitude, longitude (with `includeDetails`) |
| changeType / firstSeenAt / lastSeenAt / isRepost | Monitoring fields (with `incrementalMode`) |
| geo / query / scrapedAt / portalUrl | Run context |

### Output example

```json
{
  "jobKey": "107929852",
  "title": "Software Engineer",
  "company": "Cpl",
  "location": "Galway",
  "url": "https://www.jobs.ie/job/software-engineer/cpl-job107929852",
  "datePosted": "2026-09-02T15:00:14.223Z",
  "postedDaysAgo": 1,
  "salary": "€ Not Disclosed",
  "isSponsored": false,
  "isHighlighted": false,
  "companyId": 1313754,
  "companyUrl": "https://www.jobs.ie/jobs/cpl?cmpId=1313754&cmp=1",
  "companyLogoUrl": "https://www.jobs.ie/CompanyLogos/f9c17f10-b930-4bef-8c5f-4e571f519c3b.png",
  "textSnippetCleaned": "Role: Software Engineer Type: Permanent Location: Remote ...",
  "harmonisedId": "4a9804c1-d9c2-4b77-be2f-c32517a4a7ca",
  "publishFromDate": "2026-09-02T15:00:14.223Z",
  "publishToDate": "2026-10-02T22:00:00Z",
  "geo": "JOBSIE",
  "query": "software developer",
  "scrapedAt": "2026-09-03T10:52:29.916Z",
  "portalUrl": "https://www.jobs.ie",
  "detailsFetched": true,
  "descriptionHtml": "<div><p><strong>Role: </strong>Software Engineer</p>...</div>",
  "descriptionText": "Role: Software Engineer Type: Permanent ...",
  "employmentType": ["FULL_TIME", "REMOTE_WORKING"],
  "validThrough": "2026-10-02T22:00:00Z",
  "industry": "IT, IT-Software Development",
  "directApply": true,
  "locationDetail": { "city": "Galway", "country": "IE", "lat": 52.632545, "lng": -8.947781 }
}
```

Download the dataset as **JSON, CSV, Excel, HTML, or XML** from the Storage tab or the [Apify API](https://docs.apify.com/api/v2).

### Use cases

- **Ireland jobs board** — feed an aggregator or alert service with live Jobs.ie vacancies.
- **Recruitment-market research** — measure hiring volume by role, county, and contract type.
- **Salary benchmarking** — collect advertised salary ranges across a role or sector.
- **Employer monitoring** — start from a company-filtered URL and track everything a company posts.
- **LLM and MCP data source** — pipe compact, structured job data into agents and downstream tools.

### How it works

1. **Search** — the scraper builds a Jobs.ie search URL from your `query`, `location`, and filters (25 jobs per page) and reads the structured result data embedded in each page.
2. **Paginate** — it pages through results up to `maxResults` or the end of the listing.
3. **Detail** — when `includeDetails` is on, each job advert page is fetched for the full description, employment type, industry, and geo-coordinates.
4. **Monitor** — in incremental mode, the run is compared against the stored state for your `stateKey` and only new, updated, reappeared, or expired jobs are returned.
5. **Resilience** — requests use rotating Apify Proxy IPs and are paced and retried, so large runs stay complete.

### How much does it cost to scrape Jobs.ie?

This actor is **pay per result** — charged once per job saved to the dataset.

| Plan | Price per 1,000 jobs |
|------|----------------------|
| Free | **$0.99** |
| Bronze | **$0.89** |
| Silver | **$0.89** |
| Gold | **$0.79** |

A small platform **Actor start** fee also applies per run. `maxResults` is the exact number of billed rows. Scraping 1,000 jobs on the Free plan costs about **$0.99**. Apify's monthly free platform usage covers small runs.

### How to scrape Jobs.ie

1. Click **Try for free** and sign in to Apify.
2. Enter a **search keyword** and, optionally, a **location**.
3. Add filters — contract type, advertiser type, minimum salary, or posting age.
4. Set **max results** (start low, e.g. 25).
5. Optionally turn on **Fetch full job descriptions**.
6. Click **Start**, then watch rows appear in the **Output** tab.
7. Export from **Storage**, or pull results via the API.

#### Run it via API

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("parsebird/jobs-ie-scraper").call(run_input={
    "query": "software developer",
    "location": "Dublin",
    "maxResults": 50,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "-", job["company"], "-", job.get("salary"))
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('parsebird/jobs-ie-scraper').call({
    query: 'accountant',
    companyType: 'direct',
    maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Schedule recurring runs, add webhooks, or push results to Google Sheets, Slack, Zapier, and Make with [Apify integrations](https://docs.apify.com/platform/integrations).

### FAQ

**Do I need a Jobs.ie account or API key?**
No. The scraper reads public Jobs.ie pages only. Jobs.ie has no public API — this actor is the alternative.

**How current is the data?**
Live. Each run reads Jobs.ie at that moment. Use Apify's scheduler to keep a dataset fresh, and `incrementalMode` to receive only what changed.

**What does turning on `includeDetails` change?**
The scraper opens each job page and adds `descriptionHtml`, `descriptionText`, `employmentType`, `industry`, `validThrough`, `directApply`, and `locationDetail`. It is slower and makes more requests, so leave it off for fast listing-only runs.

**How does incremental monitoring work?**
The first run with a given `stateKey` records a baseline. Later runs return only jobs that are new, updated, or reappeared. Add `emitUnchanged` or `emitExpired` to widen the output, and `skipReposts` to drop re-advertised jobs.

**Why does a search return fewer results than the website shows?**
Jobs.ie counts loosely and includes nearby locations; a narrow keyword plus a small town can legitimately return only a handful of vacancies. Increase `radius` or broaden the keyword.

**Something's not working.**
Open an issue on the **Issues** tab with your input and the run link — we respond quickly.

### Is it legal to scrape Jobs.ie?

Jobs.ie vacancy adverts are public information that any visitor can see without logging in. Scraping publicly available pages is legal in most jurisdictions, and this actor does not access private data or bypass any login. You are responsible for how you use the data — follow Jobs.ie's Terms of Use and the GDPR when handling any personal data, and consult a lawyer if you are unsure. See Apify's guide on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Related actors

- [NHS UK Jobs Scraper](https://apify.com/parsebird/nhs-uk-jobs-scraper) — vacancies from the official NHS Jobs board.
- [Indeed Jobs Scraper](https://apify.com/parsebird/indeed-jobs-scraper) — job listings from Indeed worldwide.
- [hh.ru Jobs Scraper](https://apify.com/parsebird/hh-ru-jobs-scraper) — vacancies from HeadHunter (Russia).
- [Freshersworld Jobs Scraper](https://apify.com/parsebird/freshersworld-jobs-scraper) — India fresher and entry-level jobs.

Browse all [ParseBird actors](https://apify.com/parsebird) on Apify Store.

# Actor input Schema

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

Public Jobs.ie search URLs (for example `https://www.jobs.ie/jobs/software-developer/in-dublin`) or single-job URLs (`https://www.jobs.ie/job/.../...jobNNNNNN`). When set, these take precedence over the keyword and filters below.

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

Job title, role, or skill to search for on Jobs.ie, for example `software developer`, `accountant`, or `warehouse operative`. Required unless Start URLs is set.

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

City, county, or province in Ireland, for example `Dublin`, `Cork`, `County Galway`, or `Munster`.

## `jobType` (type: `string`):

Restrict results to one contract type.

## `sort` (type: `string`):

Order results are returned in.

## `postedWithinDays` (type: `string`):

Only return jobs posted within this window.

## `companyType` (type: `string`):

Filter by who posted the job.

## `minSalary` (type: `integer`):

Minimum salary to filter by, in euro. Combine with the salary period below (for example 40000 per year, or 20 per hour).

## `salaryPeriod` (type: `string`):

The period the minimum salary applies to.

## `radius` (type: `integer`):

Search radius around the location in kilometres. Only applies when a location is set. 0 uses the Jobs.ie default.

## `includeDetails` (type: `boolean`):

Open each job page to add the full description (HTML and text), employment type, industry, geo-coordinates, and valid-through date. Slower and more requests — leave off for a fast listing-only run.

## `compact` (type: `boolean`):

Return only core fields (title, company, location, salary, URL, dates, change type) — ideal for alerts, LLMs, and MCP data sources.

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

Maximum number of jobs to return. This is the number of billed rows. Start small and raise it after checking the search.

## `maxPagesPerSearch` (type: `integer`):

Safety limit on how many result pages to page through per search (25 jobs per page).

## `incrementalMode` (type: `boolean`):

Compare this run against previous runs with the same state key and return only jobs that are new, updated, or reappeared. The first run records a baseline.

## `stateKey` (type: `string`):

A stable name that separates one watchlist or schedule from another.

## `emitUnchanged` (type: `boolean`):

Also return jobs whose tracked content did not change since the last run.

## `emitExpired` (type: `boolean`):

Also return a record for jobs that were present before but have now disappeared from the search.

## `skipReposts` (type: `boolean`):

Drop new listings that match the tracked content of a previously expired job.

## `notificationWebhookUrl` (type: `string`):

Optional HTTPS endpoint that receives a compact JSON summary after a monitoring run.

## `proxyConfiguration` (type: `object`):

Jobs.ie rate-limits by IP and blocks most datacenter ranges, so Irish residential routing is preset. Change it only for an account-specific setup.

## Actor input object example

```json
{
  "startUrls": [],
  "query": "software developer",
  "jobType": "any",
  "sort": "relevance",
  "postedWithinDays": "0",
  "companyType": "any",
  "salaryPeriod": "annual",
  "includeDetails": false,
  "compact": false,
  "maxResults": 25,
  "maxPagesPerSearch": 40,
  "incrementalMode": false,
  "stateKey": "default",
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}
```

# Actor output Schema

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

No description

# 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": [],
    "query": "software developer",
    "location": "",
    "minSalary": 0,
    "radius": 0,
    "maxResults": 25,
    "maxPagesPerSearch": 40,
    "stateKey": "default",
    "notificationWebhookUrl": "",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/jobs-ie-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": [],
    "query": "software developer",
    "location": "",
    "minSalary": 0,
    "radius": 0,
    "maxResults": 25,
    "maxPagesPerSearch": 40,
    "stateKey": "default",
    "notificationWebhookUrl": "",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/jobs-ie-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": [],
  "query": "software developer",
  "location": "",
  "minSalary": 0,
  "radius": 0,
  "maxResults": 25,
  "maxPagesPerSearch": 40,
  "stateKey": "default",
  "notificationWebhookUrl": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}' |
apify call parsebird/jobs-ie-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/jobs-ie-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/hK9qJQILXFZFqlhbu/builds/OIPYE5qC00vYw0ybC/openapi.json