# Adzuna Job Aggregator Scraper (`parseforge/adzuna-scraper`) Actor

Scrape aggregated job listings from Adzuna across 19 countries. Extract title, company, salary (real + estimated), location, geo coordinates. Filter by category, contract, hours, salary, date posted.

- **URL**: https://apify.com/parseforge/adzuna-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.75 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 💼 Adzuna Job Aggregator Scraper

> 🚀 **Pull aggregated job listings from Adzuna in seconds.** Filter by keyword, location, salary, contract type, hours, category, and remote-only. No API key, no registration, no CSV wrangling.

> 🕒 **Last updated:** 2026-05-08 · **📊 30 fields** per record · **19 country domains** · **Real and Jobsworth-estimated salaries** · **Geo-coordinates included**

Adzuna is a meta-search engine for jobs. It pulls postings from thousands of source sites (employer career pages, recruitment agencies, partner job boards) and unifies them under a single, well-structured listing. This Actor walks Adzuna's public search results across **19 country domains**, paginates through every result, and returns a clean record per job with title, employer, location, salary, employment type, full description, geo-coordinates, posting date, and a permanent Adzuna URL. Each record also includes Adzuna's **Jobsworth predicted salary**, a regression-based estimate the platform applies when an employer omits a salary band.

The Actor uses Adzuna's listing pages plus per-job detail pages, parsing **JSON-LD `JobPosting` schema** for structured data and the rendered HTML for fields that are only visible in the UI (Jobsworth estimates, multi-location flags, sponsored-listing indicators). Apify's residential proxy network handles country routing automatically based on the chosen domain. Sponsored ads (which Adzuna proxies through external redirects rather than hosting on their own detail page) are still captured, with the listing-card snippet falling in for the description so no record is lost.

| 🎯 Target Audience | 🛠 Primary Use Cases |
|---|---|
| Recruiters and talent sourcers | Cross-platform job aggregation across multiple sources |
| Salary researchers and HR analysts | Salary benchmarking using both real and Jobsworth-estimated bands |
| Job market analysts | Tracking hiring volume by category, region, and contract type |
| Career sites and ATS vendors | Backfilling job feeds with verified meta-aggregated data |
| Researchers and journalists | UK and global labour-market analysis from public listings |

---

### 📋 What the Adzuna Job Aggregator Scraper does

- 🔍 **Multi-keyword search.** Provide one or many search keywords. Each query becomes its own Adzuna search and the Actor aggregates unique jobs across all of them.
- 🌍 **19 country domains.** Choose UK, US, Australia, Canada, India, Germany, France, Spain, Italy, Netherlands, Belgium, Brazil, Mexico, New Zealand, Poland, Singapore, South Africa, Switzerland, or Austria. Proxy routing follows automatically.
- 💰 **Salary filtering and parsing.** Pass a minimum salary threshold and the Actor will pre-filter on Adzuna. Every record is parsed for currency, period (per year, per hour, per day), min, and max so you can sort numerically downstream.
- 🧱 **Filters that match the Adzuna UI.** Category, contract type (permanent or contract), hours (full or part time), date posted (24h, 3d, 7d), remote-only, and sort order (relevance, recent, highest or lowest salary).
- 📄 **Full descriptions via JSON-LD.** Every non-sponsored job has its detail page fetched for full description, geo-coordinates, postal address, posting date, and validity window.
- 🔗 **Custom URL mode.** Already have an Adzuna search URL with the exact filters you want? Paste it under "Custom search URLs" and the Actor will replay it without rebuilding.

Each record carries the company name, logo URL, normalised location, multi-location array, salary fields (text plus parsed min/max/currency/period plus an `estimated` flag for Jobsworth bands), employment type, contract type, posting date, validity date, category, industry, snippet, full description, latitude, longitude, postal code, address locality / region / country, direct-apply flag, immediate-start flag, the Adzuna detail URL, and the partner apply URL when present.

> 💡 **Why it matters:** Adzuna covers millions of postings the big single-source boards miss because it pulls directly from corporate career pages, recruitment agencies, and partner sites. Their **Jobsworth model** also fills in salary bands for jobs that ship without one, giving you a usable comparison baseline.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing keyword setup, country routing, salary filtering, and downstream salary-benchmarking use cases.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Cap on the number of jobs returned. Free plans cap at 10. Paid plans up to 1,000,000.</td></tr>
<tr><td><code>searchQueries</code></td><td>array of strings</td><td>No</td><td>One or many keywords. Each becomes its own Adzuna search.</td></tr>
<tr><td><code>where</code></td><td>string</td><td>No</td><td>Free-text location: city, county, region, or postcode.</td></tr>
<tr><td><code>country</code></td><td>enum</td><td>No</td><td>Adzuna country domain. Defaults to <code>uk</code>. 19 supported.</td></tr>
<tr><td><code>category</code></td><td>enum</td><td>No</td><td>Restrict to one Adzuna category (IT, Engineering, Sales, Healthcare, etc.).</td></tr>
<tr><td><code>contractType</code></td><td>enum</td><td>No</td><td><code>permanent</code> or <code>contract</code>.</td></tr>
<tr><td><code>hours</code></td><td>enum</td><td>No</td><td><code>full_time</code> or <code>part_time</code>.</td></tr>
<tr><td><code>salaryMin</code></td><td>integer</td><td>No</td><td>Minimum salary (in country currency).</td></tr>
<tr><td><code>datePosted</code></td><td>enum</td><td>No</td><td><code>1</code>, <code>3</code>, or <code>7</code> days. Restricts to recent postings.</td></tr>
<tr><td><code>sortBy</code></td><td>enum</td><td>No</td><td><code>relevance</code>, <code>date</code>, <code>salary_desc</code>, <code>salary_asc</code>.</td></tr>
<tr><td><code>remoteOnly</code></td><td>boolean</td><td>No</td><td>Restrict to remote-only positions.</td></tr>
<tr><td><code>fetchDetails</code></td><td>boolean</td><td>No</td><td>Visit each job's detail page for full description and geo. Defaults to true.</td></tr>
<tr><td><code>searchUrls</code></td><td>array of strings</td><td>No</td><td>Override every other search input by pasting fully-formed Adzuna URLs.</td></tr>
<tr><td><code>proxyConfiguration</code></td><td>object</td><td>No</td><td>Apify proxy. Residential is the default and recommended.</td></tr>
</table>

Example: London software engineer roles, 3 days, full-time only.

```json
{
  "maxItems": 50,
  "searchQueries": ["software engineer"],
  "where": "London",
  "country": "uk",
  "datePosted": "3",
  "hours": "full_time",
  "sortBy": "date"
}
````

Example: salary research across multiple keywords in the US.

```json
{
  "maxItems": 200,
  "searchQueries": ["data scientist", "machine learning engineer", "ml engineer"],
  "country": "us",
  "salaryMin": 120000,
  "sortBy": "salary_desc",
  "fetchDetails": true
}
```

> ⚠️ **Good to Know:** Sponsored Adzuna listings (the ones flagged with `applyUrl` set) redirect to external partner sites instead of being hosted on Adzuna's own detail page. For these, the Actor uses the listing-card snippet as the description so the record is still complete, but employment type, geo-coordinates, and validity dates may be null.

***

### 📊 Output

Every record is one job, one row. Free plan returns 10. Paid plans up to 1,000,000.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `companyLogoUrl` | string | `https://zunastatic-abf.kxcdn.com/.../logo.png` |
| 📌 `title` | string | `Software Engineer` |
| 🏢 `company` | string | `BARCLAYS UK` |
| 📍 `location` | string | `LONDON, LONDON` |
| 🗺️ `locationParts` | array | `["LONDON", "LONDON"]` |
| 💷 `salary` | string | `£46,922 per year` |
| 📊 `salaryMin` | number | `46922` |
| 📈 `salaryMax` | number | `null` |
| 💱 `salaryCurrency` | string | `£` |
| 🕒 `salaryPeriod` | string | `year` |
| 🤖 `salaryEstimated` | boolean | `true` (Jobsworth estimate) |
| 🛠️ `employmentType` | string | `FULL_TIME` |
| 📜 `contractType` | string | `permanent` |
| 📅 `datePosted` | datetime | `2026-04-30T00:33:37` |
| ⏳ `validThrough` | datetime | `2026-05-22T00:42:36` |
| 📁 `category` | string | `IT` |
| 🏭 `industry` | string | `IT` |
| 📝 `snippet` | string | `To be successful as a Software Engineer ...` |
| 📃 `description` | string | `<p>To be successful ...</p>` (HTML) |
| 🌐 `latitude` | number | `51.503378` |
| 🌐 `longitude` | number | `-0.139134` |
| 📮 `postalCode` | string | `SW1A` |
| 🏙️ `addressLocality` | string | `London` |
| 🌍 `addressRegion` | string | `UK` |
| 🇬🇧 `addressCountry` | string | `UK` |
| 🚀 `directApply` | boolean | `false` |
| ⚡ `immediateStart` | boolean | `false` |
| 🆔 `jobId` | string | `5714125503` |
| 🔗 `url` | string | `https://www.adzuna.co.uk/jobs/details/5714125503` |
| 📤 `applyUrl` | string | `null` (or partner redirect URL) |
| 🔍 `searchQuery` | string | `software engineer` |
| 🔎 `searchUrl` | string | `https://www.adzuna.co.uk/search?q=software+engineer&w=London` |
| 🇺🇳 `country` | string | `uk` |
| ⏱️ `scrapedAt` | datetime | `2026-05-08T01:12:16.540Z` |
| ⚠️ `error` | string | only present on failed records |

#### 📦 Sample records

<details>
<summary>Typical record (full detail-page enrichment)</summary>

```json
{
  "companyLogoUrl": "https://zunastatic-abf.kxcdn.com/images/logo/jobs/partners/tu4jEzfyCOGYlOoBqiagJSXd7Vs.png",
  "title": "Software Engineer",
  "company": "BARCLAYS UK",
  "location": "LONDON, LONDON",
  "locationParts": ["LONDON", "LONDON"],
  "salary": "£46,922 per year",
  "salaryMin": 46922,
  "salaryMax": null,
  "salaryCurrency": "£",
  "salaryPeriod": "year",
  "salaryEstimated": true,
  "employmentType": "FULL_TIME",
  "datePosted": "2026-04-30T00:33:37",
  "validThrough": "2026-05-22T00:42:36",
  "category": "IT",
  "industry": "IT",
  "snippet": "To be successful as a Software Engineer you should: C## .NET RESTful Web APIs.NET Core SQL queries...",
  "description": "<p>To be successful as a Software Engineer you should:</p><ul><li>C## .NET RESTful Web APIs.NET Core</li><li>SQL queries, stored procedures, and database objects for SQL Server</li><li>Experience in AI/ML models, neural networks, LLM-based systems</li></ul>...",
  "latitude": 51.503378,
  "longitude": -0.139134,
  "postalCode": "SW1A",
  "addressLocality": "London",
  "addressRegion": "UK",
  "addressCountry": "UK",
  "directApply": false,
  "immediateStart": false,
  "jobId": "5714125503",
  "url": "https://www.adzuna.co.uk/jobs/details/5714125503",
  "applyUrl": null,
  "searchQuery": "software engineer",
  "country": "uk",
  "scrapedAt": "2026-05-08T01:12:16.540Z"
}
```

</details>

<details>
<summary>Edge case: part-time role with full address and Jobsworth estimate</summary>

```json
{
  "title": "Software Engineer",
  "company": "HOSTHELP",
  "location": "LONDON",
  "salary": "£44,400 per year",
  "salaryMin": 44400,
  "salaryEstimated": true,
  "employmentType": "PART_TIME",
  "datePosted": "2022-03-26T00:00:00",
  "validThrough": "2026-05-21T03:13:49",
  "category": "IT",
  "industry": "IT",
  "latitude": 51.503378,
  "longitude": -0.139134,
  "postalCode": "SW1A",
  "addressLocality": "London",
  "addressRegion": "UK",
  "addressCountry": "UK",
  "directApply": false,
  "immediateStart": false,
  "jobId": "4500004165",
  "url": "https://www.adzuna.co.uk/jobs/details/4500004165",
  "applyUrl": null,
  "country": "uk"
}
```

</details>

<details>
<summary>Sparse: sponsored listing with partner redirect (snippet fills in for description, geo unknown)</summary>

```json
{
  "title": "Software Engineer",
  "company": "SANDERSON GOVERNMENT AND DEFENCE",
  "location": "SOUTH EAST",
  "salary": "£70,000",
  "salaryMin": 70000,
  "salaryCurrency": "£",
  "salaryEstimated": false,
  "employmentType": null,
  "datePosted": null,
  "category": null,
  "snippet": "... and Communication systems. Software engineering experience from R&D concept through to the full product development lifecycle...",
  "description": "... and Communication systems. Software engineering experience from R&D concept through to the full product development lifecycle...",
  "latitude": null,
  "longitude": null,
  "addressLocality": null,
  "directApply": null,
  "jobId": "5686523939",
  "url": "https://www.adzuna.co.uk/jobs/details/5686523939",
  "applyUrl": "https://www.adzuna.co.uk/jobs/land/ad/5686523939?se=cmDx8XpK8RG354-18BPzqQ&title=Software_Engineer&v=A5DA7DFEAEDA53CA529C822CDF5D556769919B11",
  "country": "uk"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **19 country domains.** UK, US, Australia, Canada, India, Germany, France, Spain, Italy, Netherlands, Belgium, Brazil, Mexico, New Zealand, Poland, Singapore, South Africa, Switzerland, Austria. |
| 💰 | **Real and predicted salaries.** When the employer omits a band, Adzuna's Jobsworth regression estimate is captured separately, so you can filter on `salaryEstimated`. |
| 🗺️ | **Geo-coordinates per record.** Latitude, longitude, postal code, locality, region, and country, parsed from JSON-LD. |
| 📃 | **Full HTML descriptions.** Pulled from each job's detail page using the schema.org `JobPosting` markup. |
| 🧱 | **Filter parity with Adzuna UI.** Category, contract type, hours, salary minimum, date posted, remote-only, sort order. |
| 🛡️ | **Anti-blocking via residential proxies.** Apify residential network with country-aligned routing. |
| 📊 | **Clean output schema.** 30+ fields, every column populated where the source has it. Sponsored ads gracefully degrade to listing-card data instead of leaving blank rows. |

> 📊 Adzuna's UK index alone surfaces over **1.5 million live jobs** across 30+ categories, with continuous freshness from partner crawlers.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Adzuna Job Aggregator Scraper** *(this Actor)* | Pay per item | 19 countries, full UI parity | Live | Category, salary, contract, hours, date, remote, sort | Zero config |
| Official aggregator APIs | Per-call rate limits, registration required | Varies, often gated | Live | Limited | API key required |
| Generic listings scrapers | Free / open-source | Single source per build | Manual | None | High maintenance |
| Manual CSV exports | Free | Single snapshot | One-shot | None | Manual rebuilds |

When you want repeatable, filterable, structured Adzuna jobs without managing crawler infrastructure, this Actor is the path of least resistance.

***

### 🚀 How to use

1. 🔐 **Sign up.** Create a free [Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (no card required for the free tier).
2. 🔍 **Find the Actor.** Search "Adzuna Job Aggregator Scraper" in the Apify Store, or open it directly from the ParseForge collection.
3. ⚙️ **Set inputs.** Pick a country, drop in one or more keywords, set a location, and tune filters (salary, contract, hours, date posted).
4. ▶️ **Run.** Click Start. Watch the live log as each search and detail page is processed.
5. 📥 **Export.** Pull results as JSON, CSV, Excel, RSS, or push directly into Sheets, Slack, BigQuery, or any webhook.

> ⏱️ Total time: under 2 minutes from sign-up to first download.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 🧑‍💼 Recruiters and talent sourcers

- Build a daily aggregated feed across all source sites
- Detect newly posted roles ahead of single-source competitors
- Lead-mine companies that hire your candidate's specialty
- Cross-reference with LinkedIn for direct outreach

</td>
<td width="50%">

#### 📊 Salary researchers and HR analysts

- Benchmark compensation by role, region, and seniority
- Track salary drift over time using validity dates as snapshots
- Build country-by-country comparison dashboards
- Use Jobsworth estimates to fill bands employers omit

</td>
</tr>
<tr>
<td width="50%">

#### 📈 Job-market analysts

- Quantify hiring volume by category, region, and contract type
- Detect demand spikes for specific skills or technologies
- Track post-recession hiring recovery week by week
- Generate quarterly reports on UK or US labour markets

</td>
<td width="50%">

#### 🛠 ATS vendors and career sites

- Backfill aggregated job feeds for white-label products
- Power salary-comparison widgets with live data
- Enrich candidate-facing search with multi-source listings
- Auto-populate "similar jobs" carousels using shared categories

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Adzuna Job Aggregator Scraper

Run on demand from your own code, or set it on a schedule.

- **[Node.js client](https://docs.apify.com/api/client/js)** for JavaScript and TypeScript callers
- **[Python client](https://docs.apify.com/api/client/python)** for data-science workflows and notebooks
- **[REST API docs](https://docs.apify.com/api/v2)** for any language with HTTP

Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run this Actor every hour, every morning, or once a week. Combine with Webhooks to push new postings into Slack, a database, or your ATS the moment they are scraped.

***

### ❓ Frequently Asked Questions

<details>
<summary>📦 <b>Can I use the data commercially?</b></summary>
Yes. The data is scraped from publicly accessible Adzuna pages. You retain rights to use it in commercial products, dashboards, or reports. Be mindful of Adzuna's Terms of Service and applicable local data-protection regulations.
</details>

<details>
<summary>💳 <b>Do I need a paid plan?</b></summary>
No. The free Apify tier returns up to 10 jobs per run, which is enough to validate the schema and try the filters. Paid plans unlock up to 1,000,000 items per run.
</details>

<details>
<summary>🚨 <b>What happens if a run fails?</b></summary>
Failed records are pushed to the dataset with an `error` field describing the cause. The Actor never crashes hard; you always get the items it managed to extract before the failure.
</details>

<details>
<summary>⚖️ <b>Is this legal?</b></summary>
We scrape only public, anonymously accessible Adzuna pages and respect their robots.txt. The Actor is for users to research the public job market. You are responsible for compliance with the Adzuna ToS and your local laws.
</details>

<details>
<summary>🌍 <b>Which countries are supported?</b></summary>
19 Adzuna country domains: United Kingdom, United States, Australia, Austria, Belgium, Brazil, Canada, France, Germany, India, Italy, Mexico, Netherlands, New Zealand, Poland, Singapore, South Africa, Spain, and Switzerland.
</details>

<details>
<summary>💰 <b>What is the Jobsworth salary?</b></summary>
Jobsworth is Adzuna's predicted salary, applied when an employer ships a posting without one. The Actor exposes both the text (`salary`) and a parsed `salaryMin`, plus a `salaryEstimated` boolean so you can split real vs predicted bands in your downstream analysis.
</details>

<details>
<summary>📃 <b>Why are some records missing description, datePosted, or geo?</b></summary>
Adzuna treats some sponsored listings as external redirects (the `applyUrl` field is populated). For these, Adzuna does not host a detail page, so the JSON-LD enrichment fields are unavailable. The Actor falls back to the listing-card snippet so you still get title, company, location, salary, and a description.
</details>

<details>
<summary>🔄 <b>How fresh is the data?</b></summary>
Live. Adzuna re-crawls partner sites continuously and the Actor scrapes their listing pages on every run. The `datePosted` field on each job tells you exactly when the underlying employer published it.
</details>

<details>
<summary>🛡️ <b>Why is residential proxy required?</b></summary>
Adzuna rate-limits datacenter IP ranges aggressively (HTTP 429 within seconds). Apify residential proxies route through real ISP pools and are paired with a session-rotating retry scheme to avoid blocks.
</details>

<details>
<summary>🔍 <b>Can I scrape a single Adzuna search URL I already have?</b></summary>
Yes. Use the `searchUrls` advanced field. Paste any fully-formed Adzuna search URL (with whatever filters you want) and the Actor will replay it directly without rebuilding from inputs.
</details>

<details>
<summary>⚡ <b>Can I skip detail-page fetches for speed?</b></summary>
Yes. Set `fetchDetails: false`. You will get title, company, location, salary, snippet, logo, and IDs from the listing card, but no full HTML description, no geo, and no validity dates. About 4-5x faster.
</details>

<details>
<summary>📊 <b>Can I sort by salary?</b></summary>
Yes. Set `sortBy: "salary_desc"` or `salary_asc`. Adzuna applies the sort server-side, so the first records in your dataset will be the highest or lowest paying matches in the search.
</details>

***

### 🔌 Integrate with any app

- [**Zapier**](https://apify.com/integrations/zapier) - hundreds of no-code triggers and actions
- [**Make**](https://apify.com/integrations/make) - visual automation builder
- [**n8n**](https://apify.com/integrations/n8n) - self-hosted workflow automation
- [**Slack**](https://apify.com/integrations/slack) - push new jobs into a channel
- [**Google Sheets**](https://apify.com/integrations/google-drive) - auto-append daily runs to a spreadsheet
- [**Airbyte**](https://apify.com/integrations/airbyte) - pipe results into your data warehouse

***

### 🔗 Recommended Actors

- [**💼 LinkedIn Jobs Scraper**](https://apify.com/parseforge/linkedin-jobs-scraper) - postings from LinkedIn's job board with company and salary signals
- [**🟦 Indeed Scraper**](https://apify.com/parseforge/indeed-scraper) - the world's largest job search engine, with full filters
- [**🟢 Glassdoor Jobs Scraper**](https://apify.com/parseforge/glassdoor-jobs-scraper) - Glassdoor postings paired with employer ratings
- [**🔍 Google Jobs Scraper**](https://apify.com/parseforge/google-jobs-scraper) - Google's job aggregator surface results
- [**📋 SimplyHired Scraper**](https://apify.com/parseforge/simplyhired-scraper) - SimplyHired listings across the US

> 💡 Pro Tip: browse the complete [ParseForge collection](https://apify.com/parseforge) for more job, salary, and labour-market scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA)

***

> **Disclaimer.** This Actor scrapes only public Adzuna pages. It does not bypass authentication, paywalls, or technical protection measures. You are responsible for using the resulting data in compliance with Adzuna's Terms of Service and your local laws (including GDPR, CCPA, and copyright). ParseForge does not affiliate with, endorse, or claim any partnership with Adzuna.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Job titles, keywords, or company names to search on Adzuna. Each entry becomes a separate search and the Actor aggregates unique jobs across all of them.

## `where` (type: `string`):

City, county, region, or postcode to scope the search (e.g. 'London', 'Manchester', 'SW1A'). Leave blank to search nationally.

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

Adzuna country domain. Each country has its own job inventory.

## `category` (type: `string`):

Restrict search to a single Adzuna job category. The numeric category IDs match Adzuna's internal taxonomy.

## `contractType` (type: `string`):

Filter by contract type. Permanent or contract roles only.

## `hours` (type: `string`):

Filter by working hours.

## `salaryMin` (type: `integer`):

Restrict to jobs with advertised salary at or above this number (in the country's local currency).

## `datePosted` (type: `string`):

Restrict to jobs posted in the last N days. 1, 3, or 7.

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

Order in which Adzuna returns results.

## `remoteOnly` (type: `boolean`):

Restrict to remote / work-from-home positions only.

## `fetchDetails` (type: `boolean`):

If enabled, the Actor visits each job's detail page to extract the full description, geo-coordinates, postal address, validity date, and JSON-LD JobPosting fields. Slower but produces richer records. If disabled, only listing-card fields are captured.

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

Optional: paste fully-formed Adzuna search URLs (e.g. https://www.adzuna.co.uk/search?q=python\&w=london\&cti=full\_time). When provided, these override searchQueries / where / country / filters. Useful when you have an exact filter combination from the Adzuna UI you want to replay.

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

Apify residential proxy is required: Adzuna rate-limits datacenter IPs and direct requests aggressively. Country routing is matched to the chosen Adzuna domain automatically.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQueries": [
    "software engineer"
  ],
  "country": "uk",
  "category": "",
  "contractType": "",
  "hours": "",
  "datePosted": "",
  "sortBy": "relevance",
  "remoteOnly": false,
  "fetchDetails": true,
  "searchUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Table view with key job fields and links.

## `fullData` (type: `string`):

Complete dataset with all extracted fields including JSON-LD details.

# 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 = {
    "maxItems": 10,
    "searchQueries": [
        "software engineer"
    ],
    "where": "",
    "searchUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/adzuna-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 = {
    "maxItems": 10,
    "searchQueries": ["software engineer"],
    "where": "",
    "searchUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/adzuna-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 '{
  "maxItems": 10,
  "searchQueries": [
    "software engineer"
  ],
  "where": "",
  "searchUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/adzuna-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Adzuna Job Aggregator Scraper",
        "description": "Scrape aggregated job listings from Adzuna across 19 countries. Extract title, company, salary (real + estimated), location, geo coordinates. Filter by category, contract, hours, salary, date posted.",
        "version": "1.0",
        "x-build-id": "lS0KX1dPBhgifuFI5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~adzuna-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-adzuna-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/parseforge~adzuna-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-adzuna-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/parseforge~adzuna-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-adzuna-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job titles, keywords, or company names to search on Adzuna. Each entry becomes a separate search and the Actor aggregates unique jobs across all of them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "where": {
                        "title": "Location (free text)",
                        "type": "string",
                        "description": "City, county, region, or postcode to scope the search (e.g. 'London', 'Manchester', 'SW1A'). Leave blank to search nationally."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "uk",
                            "us",
                            "au",
                            "at",
                            "be",
                            "br",
                            "ca",
                            "ch",
                            "de",
                            "es",
                            "fr",
                            "in",
                            "it",
                            "mx",
                            "nl",
                            "nz",
                            "pl",
                            "sg",
                            "za"
                        ],
                        "type": "string",
                        "description": "Adzuna country domain. Each country has its own job inventory.",
                        "default": "uk"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "29",
                            "30"
                        ],
                        "type": "string",
                        "description": "Restrict search to a single Adzuna job category. The numeric category IDs match Adzuna's internal taxonomy.",
                        "default": ""
                    },
                    "contractType": {
                        "title": "Contract type",
                        "enum": [
                            "",
                            "permanent",
                            "contract"
                        ],
                        "type": "string",
                        "description": "Filter by contract type. Permanent or contract roles only.",
                        "default": ""
                    },
                    "hours": {
                        "title": "Hours",
                        "enum": [
                            "",
                            "full_time",
                            "part_time"
                        ],
                        "type": "string",
                        "description": "Filter by working hours.",
                        "default": ""
                    },
                    "salaryMin": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Restrict to jobs with advertised salary at or above this number (in the country's local currency)."
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7"
                        ],
                        "type": "string",
                        "description": "Restrict to jobs posted in the last N days. 1, 3, or 7.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date",
                            "salary_desc",
                            "salary_asc"
                        ],
                        "type": "string",
                        "description": "Order in which Adzuna returns results.",
                        "default": "relevance"
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Restrict to remote / work-from-home positions only.",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "If enabled, the Actor visits each job's detail page to extract the full description, geo-coordinates, postal address, validity date, and JSON-LD JobPosting fields. Slower but produces richer records. If disabled, only listing-card fields are captured.",
                        "default": true
                    },
                    "searchUrls": {
                        "title": "Custom search URLs (advanced)",
                        "type": "array",
                        "description": "Optional: paste fully-formed Adzuna search URLs (e.g. https://www.adzuna.co.uk/search?q=python&w=london&cti=full_time). When provided, these override searchQueries / where / country / filters. Useful when you have an exact filter combination from the Adzuna UI you want to replay.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify residential proxy is required: Adzuna rate-limits datacenter IPs and direct requests aggressively. Country routing is matched to the chosen Adzuna domain automatically."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```