# Jora Job Scraper \[Only $0.20💰] | Australia | Salary Data (`ahmed_jasarevic/jora-scraper`) Actor

Scrape Australia job market data from Jora.com — the SEEK-backed job search engine. Extract job title, company, location, salary, work type, full description and apply URL into a clean structured dataset for recruitment research, salary benchmarking and hiring trend monitoring.

- **URL**: https://apify.com/ahmed\_jasarevic/jora-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.77 / 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/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

## Jora Job Scraper — Australia Job Market Data Extraction

Scrape **job listings from [Jora.com](https://au.jora.com)** — Australia's SEEK-backed job search engine and aggregator — and get job title, company, location, salary range, work type, full description and apply URL in one clean structured dataset. Built for Australia job market monitoring, salary benchmarking, and recruitment research.

### Monitor Australia Hiring Trends and Build Job Market Datasets

Run it once for a market snapshot, or schedule it daily/weekly to track hiring trends, salary ranges, and emerging roles across Australia. Jora aggregates listings from SEEK, Workforce Australia, Indeed, company career pages and recruitment agencies, so one query covers multiple sources. Data is delivered as JSON via the Apify API, with CSV/Excel export, webhooks, and Zapier/Make integrations.

### Main Use Cases

- **Australia job market intelligence** — track hiring trends, in-demand skills, and emerging roles
- **Salary benchmarking** — extract parsed salary ranges (min/max/currency/period) for compensation analysis
- **Recruitment research** — build job posting databases from SEEK, Workforce Australia and company career pages via Jora's aggregator
- **Competitor hiring analysis** — monitor which companies are hiring and for what roles
- **Labor market analytics** — build datasets for economic research and workforce planning
- **Job lead generation** — enrich applicant sourcing and talent intelligence pipelines

### How It Works

1. You pick a **market** (e.g. `au` for Australia), enter **keywords** (e.g. `software engineer`) and optionally a **location** (e.g. `Sydney NSW`)
2. The actor uses CheerioCrawler (plain HTTP) to fetch Jora's server-rendered search and job pages — no browser, no rendering, no CAPTCHA solving
3. Every request impersonates a real Chrome TLS/HTTP2 fingerprint, routes through the Apify proxy pinned to the market country, and paces requests with human-like delays to keep 403 rates near zero
4. With `fetchDetails: true`, each job's detail page is visited for the full description and direct apply URL
5. Results are saved to your dataset with structured fields including parsed salary data

### Market Availability — Australia Is the Live Market

Jora.com is operated by SEEK and currently serves the **Australian job market** (au.jora.com). Other country sites in the input schema (`nz`, `sg`, `hk`, `my`, `id`, `uk`, `us`, `ca`, `za`, `mx`) have been **closed or redirected by Jora** — those subdomains now show closure notices or point to the Australian site. The `country` field accepts all 13 legacy codes for schema compatibility, but live, complete results today come from **Australia (`au`)** with ~400,000+ listed jobs.

### Extract Job Listings and Salary Data for Market Research

#### Input

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `country` | select | No | `au` | Jora market code. Use `au` — other legacy codes are closed/redirected (see Market Availability) |
| `keywords` | string | No | `""` | Job title/skill keywords, e.g. `software engineer`. Leave empty to sweep all jobs |
| `location` | string | No | `""` | City/region filter, e.g. `Sydney NSW`. Leave empty for all locations |
| `startUrls` | array | No | `[]` | Full Jora search or job URLs to scrape directly (overrides country/keywords/location) |
| `maxItems` | integer | No | `20` | Maximum number of job listings to save (1–5000) |
| `fetchDetails` | boolean | No | `true` | Visit each job's detail page for full description + apply URL |
| `proxyConfiguration` | proxy | No | Apify proxy ON (RESIDENTIAL) | Use the **RESIDENTIAL** group — datacenter IPs (AUTO) get 403-blocked by Cloudflare |

#### Output

Each dataset item contains:

| Field | Description |
|-------|-------------|
| `jobId` | Unique Jora job identifier |
| `title` | Job title |
| `company` | Employer name |
| `location` | City/region |
| `salary` | Formatted salary string (when listed) |
| `salaryMin` / `salaryMax` | Parsed numeric salary bounds |
| `salaryPeriod` | `hour`, `day`, `week`, `month`, `year` |
| `salaryCurrency` | ISO currency code (AUD, NZD, SGD, GBP, USD, CAD, MYR, IDR, PHP, INR, HKD, ZAR, MXN) |
| `companyRating` | SEEK employer rating (when available) |
| `abstractBullets` | Bullet-point role summary |
| `sponsored` | Whether the listing is a sponsored ad |
| `isNew` | Whether Jora marks the listing as NEW |
| `workTypes` | Employment type(s): Full time, Contract, Casual, Hybrid, etc. |
| `listedDate` | Relative listing date shown by Jora |
| `sourceSite` | Original job board the listing came from (SEEK, Workforce Australia, etc.) |
| `abstract` | Short summary from the listing |
| `descriptionText` | Full description as plain text |
| `descriptionHtml` | Full description as HTML |
| `jobUrl` | Link to the job page |
| `applyUrl` | Direct apply link |
| `country` | Jora market scraped |
| `searchQuery` / `searchLocation` | The search that produced this item |
| `scrapedAt` | Run timestamp |
| `detailError` | Set when a detail page failed (listing salvaged from the search card) |

#### Example Input

```json
{
  "country": "au",
  "keywords": "software engineer",
  "location": "Sydney NSW",
  "maxItems": 100,
  "fetchDetails": true
}
```

#### Example Output

```json
{
  "jobId": "11e550611ecd03a5ccdc84b262c4d19c",
  "title": "Software Engineer",
  "company": "Conexxia",
  "location": "Pyrmont NSW",
  "salary": "$70,000 - $150,000 a year",
  "salaryMin": 70000,
  "salaryMax": 150000,
  "salaryPeriod": "year",
  "salaryCurrency": "AUD",
  "companyRating": "3.4",
  "abstractBullets": ["Build great software", "Work with a big team"],
  "sponsored": false,
  "isNew": false,
  "workTypes": ["Full time, Permanent"],
  "listedDate": "2d ago",
  "sourceSite": "Workforce Australia",
  "abstract": "We are looking for a Software Engineer to join our team...",
  "descriptionText": "Full description as plain text...",
  "descriptionHtml": "<div><p>Full description here.</p></div>",
  "jobUrl": "https://au.jora.com/job/Software-Engineer-11e550611ecd03a5ccdc84b262c4d19c",
  "applyUrl": "https://au.jora.com/job/rd/11e550611ecd03a5ccdc84b262c4d19c",
  "country": "au",
  "searchQuery": "software engineer",
  "searchLocation": "Sydney",
  "scrapedAt": "2026-09-13T00:00:00.000Z",
  "detailError": null
}
```

### Build Australian Job Databases Without Official API Access

Jora.com has no public API, and the platforms it aggregates (SEEK, Workforce Australia, Indeed) either have no public jobs API or restrict access for automation. This actor is the practical route to structured Australian job data for research, analytics and internal tools.

### Use Aggregated Job Data for Salary Benchmarking in Australia

Salary strings are parsed into structured fields (`salaryMin`, `salaryMax`, `salaryPeriod`, `salaryCurrency`), so you can filter and aggregate compensation by role, location, and source site without cleaning free-text salary data.

### Integrations & Automation

- **Webhooks** — get notified when new matching jobs appear
- **Zapier / Make** — pipe results into Google Sheets, your ATS, or notification channels
- **API** — access results programmatically via the Apify API

**Recommended schedule:** Run daily for active job searches; weekly for market intelligence and salary benchmarking; monthly for long-term trend analysis. Scheduled recurring runs also keep your Apify Store recommendations sharp.

### Related Actors

- [Seek.com.au Job Scraper](https://apify.com/automation-lab/seek-scraper) — Australia's largest job board (SEEK is Jora's parent and a key aggregated source)
- [Seek Jobs Scraper - Australia & NZ](https://apify.com/bovi/seek-jobs-scraper) — SEEK listings with salary data
- [Jora Job Listings Scraper](https://apify.com/silentflow/jora-scraper) — direct Jora scraping
- [Jora Job Scraper - 6 Countries](https://apify.com/trev0n/jora-scraper) — multi-market Jora scraping
- [Wellfound Scraper](https://apify.com/ahmed_jasarevic/wellfound-scraper) — startup jobs, salary & equity data

### FAQ

#### Why use this actor instead of the official Jora or SEEK API?

Jora.com does not offer a public jobs API, and SEEK's talent solutions API is a paid enterprise product, not a general job-listings API. Jora **aggregates** listings from multiple job boards (SEEK, Workforce Australia, Indeed, company career pages) into one search, so one Jora query covers what would require scraping several separate sites. Jora also serves server-rendered HTML, making it faster and cheaper to scrape than JavaScript-heavy platforms.

#### What are alternatives to this actor?

For direct SEEK data: [Seek.com.au Job Scraper](https://apify.com/automation-lab/seek-scraper) and [Seek Jobs Scraper - Australia & NZ](https://apify.com/bovi/seek-jobs-scraper). For other job boards: Indeed scrapers, LinkedIn Jobs scrapers, and Google Jobs scrapers on the Apify Store.

#### Is Jora really available in 13 countries?

No. The input schema keeps the 13 legacy country codes (`au`, `nz`, `sg`, `uk`, `us`, `ca`, `my`, `id`, `ph`, `in`, `hk`, `za`, `mx`) for compatibility, but Jora has **closed most of its non-Australian markets** — its New Zealand, Singapore, Hong Kong, Malaysia and Indonesia sites now show closure notices, and other subdomains redirect to the Australian site. **Australia (`au`) is the live market** and the one to use for reliable, complete results.

#### Can I scrape salary data for compensation benchmarking?

Yes — the actor parses salary strings into structured fields: `salaryMin`, `salaryMax`, `salaryPeriod`, and `salaryCurrency`. This makes it easy to filter, aggregate, and analyze salary ranges by role, location, and source site.

#### What's the difference between fetchDetails on and off?

With `fetchDetails: true` (default), each job's detail page is visited to extract the full description and apply URL. With `fetchDetails: false`, only the listing card data is saved (faster, cheaper, but no full description). A detail-mode record charges `result` + `detail` events.

#### Is scraping Jora legal?

The actor accesses only publicly available job listing pages — no login bypass, no CAPTCHA solving. Users are responsible for complying with Jora's Terms of Service and applicable data-protection law.

#### How much does it cost?

The actor uses pay-per-event pricing: $0.0002 per result saved, plus $0.0001 per full detail fetch, plus $0.0005 per actor start. A 100-job run with full details costs approximately $0.03. Free accounts get a 10-item preview; paid accounts run unlimited.

#### How many results can I get from one search?

Jora caps search results at roughly 500 per keyword/location query. To build larger datasets, split your research into multiple keyword or location searches — or pass `maxItems` up to 5000 with several `startUrls`.

### SEO Keywords

jora scraper, jora.com jobs api, jora australia, australia job market data, australia job listings api, job scraping api, seek.com.au alternative, seek jobs api, job board scraper, salary data australia, salary benchmarking tool, hiring trends australia, recruitment research australia, job aggregator data, workforce australia jobs data, job listings dataset, labour market analytics, employment market data, job search engine scraper, au job data api, sydney jobs data, melbourne jobs data, multi country job scraper

### For AI Agents & LLM Apps

**Purpose:** Scrape aggregated job listings from Jora.com (Australia's SEEK-backed job search engine), returning structured job records with parsed salary ranges, work types, source site, full description, and apply URL.

**Minimal working input:**

```json
{
  "country": "au",
  "keywords": "software engineer",
  "maxItems": 20
}
```

**Variant inputs:**

- Sweep all jobs (no keyword filter): `{ "country": "au", "maxItems": 100 }`
- Specific URL: `{ "startUrls": ["https://au.jora.com/j?sp=search&q=engineer"] }`
- Location-scoped: `{ "country": "au", "keywords": "nurse", "location": "Melbourne VIC", "maxItems": 50 }`

**Output fields:** jobId, title, company, location, salary, salaryMin, salaryMax, salaryPeriod, salaryCurrency, companyRating, abstractBullets, sponsored, isNew, workTypes, listedDate, sourceSite, abstract, descriptionText, descriptionHtml, jobUrl, applyUrl, country, searchQuery, searchLocation, scrapedAt, detailError

**Behaviors an agent should know:**

- `country` uses Jora market codes (`au`, `nz`, `sg`, …) — not country names. **Use `au` for live results**; other codes are legacy markets Jora has closed/redirected
- `startUrls` overrides `country` + `keywords` + `location` when both are provided
- `fetchDetails: true` (default) visits each job page for the full description — disable for faster, cheaper runs (it also halves per-record billing)
- Free accounts are capped at 10 items; paid runs allow up to `maxItems: 5000`; Jora returns ~500 results max per search query — split broad research across keywords/locations
- TLS fingerprint impersonation and proxy-country pinning are automatic (hard-coded); no input needed
- The RESIDENTIAL proxy group is strongly recommended — datacenter IPs get 403-blocked
- A failed detail fetch leaves the listing in the dataset with a non-null `detailError` (salvaged from the search card) — filter it out if you need complete records

**Billing model:** Pay-per-event ($0.0002 per result, $0.0001 per detail, $0.0005 per actor start)

### Legal & Compliance Disclaimer

This actor is independent and not affiliated with, endorsed by, or sponsored by Jora, SEEK Limited, or any of the job boards whose listings appear on Jora.com. It accesses only publicly available job listing pages — no login bypass, no CAPTCHA solving. Users are responsible for their own compliance with Jora's Terms of Service and applicable data-protection law (e.g. GDPR, Australian Privacy Act for personal data). Do not use scraped data for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

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

Jora country site to search. Jora runs a separate site per country.

## `keywords` (type: `string`):

Job title / skill keywords, e.g. 'software engineer'. Leave empty to sweep all jobs for the market.

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

City / region filter, e.g. 'Sydney NSW'. Leave empty for all locations.

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

Full Jora search or job URLs to scrape directly. Overrides country / keywords / location.

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

Maximum number of job listings to save.

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

Visit each job's detail page for the full description and apply URL. Slower but much richer data.

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

Route requests through the Apify proxy to avoid IP blocking. **Recommended: use the RESIDENTIAL group** — Jora sits behind Cloudflare bot protection and datacenter IPs (AUTO or a BUYPROXIES group) get 403-blocked frequently, while residential IPs pass reliably. Requires the Apify Residential Proxies add-on. If unavailable on your plan, keep the group empty (AUTO, datacenter) — it works but scrapes fewer full job pages.

## Actor input object example

```json
{
  "country": "au",
  "keywords": "",
  "location": "",
  "startUrls": [],
  "maxItems": 20,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/jora-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/jora-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/Daqu9fkacuy7Vapfz/builds/QEL14PWfmC6ySnhsw/openapi.json