# Jora Jobs Scraper (AU, NZ, SG & More) (`parsebird/jora-jobs-scraper`) Actor

Scrape job listings from Jora across Australia, New Zealand, Singapore, Hong Kong, Malaysia, and Indonesia by keyword, location, or a direct search URL.

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

## Pricing

from $0.79 / 1,000 jobs

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 Jobs Scraper (AU, NZ, SG & More)

Scrape job listings from **[Jora](https://au.jora.com)** — a job search engine covering Australia, New Zealand, Singapore, Hong Kong, Malaysia, and Indonesia — by keyword and location, or by pasting a public Jora search URL. Get structured titles, companies, locations, salaries, job types, posting dates, and full job descriptions as clean JSON, CSV, or Excel.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search any of Jora's six country sites by keyword, location, and posting date, or start from a Jora search URL — every job comes back with its full description text and HTML, salary and job-type when Jora shows one, and a stable job ID for deduplication.
</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/jora-jobs-scraper (Apify). Scrapes job listings from Jora (au.jora.com, nz.jora.com, sg.jora.com, hk.jora.com, my.jora.com, id.jora.com). Call it with ApifyClient.
Input (all optional): startUrl (string, a public Jora search URL, overrides keyword/location/country when set), keyword (string, job title/skill/phrase, default ""), location (string, city/region, default ""), country (enum: Australia|Hong Kong|Indonesia|Malaysia|New Zealand|Singapore, default "Australia"), posted_date (enum: anytime|24h|7d|30d, default "anytime"), results_wanted (integer, default 20), max_pages (integer, default 10), proxyConfiguration (object, default Jora residential preset — required, Jora blocks the default datacenter proxy).
Output: one row per job — title, company, location, salary, job_type, date_posted, description_text, description_html, url, source, job_id, sponsored, country, search_keyword, search_location, search_page.
Pricing: pay-per-event, $1.09 per 1,000 jobs on the Free plan (cheaper on paid plans). API docs: https://apify.com/parsebird/jora-jobs-scraper/api
```

### What does Jora Jobs Scraper do?

This Actor extracts job postings from [Jora](https://au.jora.com), a job search engine used across Australia, New Zealand, Singapore, Hong Kong, Malaysia, and Indonesia. It reads Jora's own server-rendered search results for the fast-moving fields (salary, job type, posting date), then opens each job's page to pull the complete description, so you don't just get a truncated summary.

- 🌏 **Six country sites** — Australia, Hong Kong, Indonesia, Malaysia, New Zealand, and Singapore, selectable with one input field.
- 🔎 **Keyword + location search** — search any role or skill (`software engineer`, `data analyst`, `warehouse`) combined with a city or region, or leave both blank for an unfiltered feed.
- 🔗 **Start URL mode** — paste a public Jora search URL (with any filters you've already applied in the browser) and the Actor scrapes from there instead of rebuilding the search.
- 📅 **Posting-date filter** — restrict results to the last 24 hours, 7 days, or 30 days.
- 💰 **Salary and job type** — parsed from Jora's own badges whenever the listing shows them (hourly, monthly, or annual, in each site's local currency).
- 📝 **Full job descriptions** — every result includes the complete `description_text` and `description_html` from the job's detail page, not just the search-result snippet.
- 🚦 **Reliable by default** — ships with a residential proxy preset, because Jora blocks Apify's default datacenter proxy outright.

#### How is this different from browsing Jora by hand?

Jora's search results page only shows a two- or three-bullet summary per job. This Actor pages through the search results, then opens each job individually to capture the real description, salary, and job type — and returns everything as structured data you can filter, sort, or pipe into another system, instead of copy-pasting from the browser.

### Input parameters

Every field is optional. With no keyword, location, or start URL, the Actor scrapes Jora's default Australia feed.

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| startUrl | string | No | Empty | Public Jora search URL to use as the starting point. |
| keyword | string | No | Empty | Job title, skill, or phrase to search for when startUrl is empty. Leave blank for an unfiltered search. |
| location | string | No | Empty | City, region, or other location filter. Leave empty for a broader search. |
| country | string | No | Australia | Jora site to search when startUrl is empty: Australia, Hong Kong, Indonesia, Malaysia, New Zealand, or Singapore. |
| posted\_date | string | No | anytime | Posting-date filter: anytime, 24h, 7d, or 30d. |
| results\_wanted | integer | No | 20 | Maximum number of jobs to save, from 1 upward. |
| max\_pages | integer | No | 10 | Maximum number of search result pages to process, from 1 upward. |
| proxyConfiguration | object | No | Jora residential preset | Apify Proxy settings. Jora blocks Apify's default datacenter proxy, so residential routing ships preset. |

#### Input example

```json
{
  "keyword": "software engineer",
  "location": "Sydney",
  "results_wanted": 20
}
```

#### Start URL example

```json
{
  "startUrl": "https://au.jora.com/j?sp=search&q=software+engineer&l=Melbourne",
  "results_wanted": 50,
  "max_pages": 20
}
```

### Output example

```json
{
  "title": "Senior Software Engineer",
  "company": "Acme Tech",
  "location": "Sydney NSW",
  "salary": "$130,000 - $160,000 per year",
  "job_type": "Full time",
  "date_posted": "2 days ago",
  "description_text": "We are looking for a Senior Software Engineer to join our platform team.",
  "description_html": "<div><p>We are looking for a Senior Software Engineer to join our platform team.</p></div>",
  "url": "https://au.jora.com/job/Senior-Software-Engineer-abcdef1234567890abcdef1234567890",
  "source": "jora",
  "job_id": "abcdef1234567890abcdef1234567890",
  "sponsored": false,
  "country": "Australia",
  "search_keyword": "software engineer",
  "search_location": "Sydney",
  "search_page": 1
}
```

### What data can you extract from Jora?

| Field | Type | Description |
|-------|------|-------------|
| title | string | Job title. |
| company | string | Company name when available. |
| location | string | Listing location when available. |
| salary | string | Salary or compensation text when Jora shows one. |
| job\_type | string | Employment type when available (e.g. Full time, Casual/Temporary). |
| date\_posted | string | Date or relative posting age when available. |
| description\_text | string | Plain-text job description from the job's detail page. |
| description\_html | string | HTML job description from the job's detail page. |
| url | string | Direct Jora job URL. |
| source | string | Listing source label (`jora`). |
| job\_id | string | Job identifier when available. |
| sponsored | boolean | Sponsored-listing indicator when available. |
| country | string | Selected Jora country site. |
| search\_keyword | string | Keyword used in the run. |
| search\_location | string or null | Location used in the run. |
| search\_page | integer or null | Search result page the job was found on. |

### How to scrape Jora jobs

1. Open the **Jora Jobs Scraper** on Apify and click **Try for free**.
2. Enter a **keyword** (e.g. `data analyst`) and a **location** (e.g. `Sydney`), or paste a full Jora search URL into **Start URL**.
3. Pick a **country** if you're not searching Australia, and optionally set a **posted date** filter.
4. Set **Results wanted** and **Max pages** — start small (e.g. 20 and 5) for a fast, cheap test run.
5. Leave the proxy on the **Jora residential** preset — Jora blocks Apify's default datacenter proxy.
6. Click **Start**, then download results as JSON, CSV, or Excel from the **Storage** tab, or pull them from the [API](https://apify.com/parsebird/jora-jobs-scraper/api).

For recurring searches, [schedule](https://docs.apify.com/platform/schedules) the Actor to run daily or weekly and feed new listings into a sheet, database, or alert.

### How much does it cost to scrape Jora?

This Actor uses the **pay-per-event** model — you are charged per job saved to the dataset, with lower rates on paid Apify plans.

| Plan | Price per job | Price per 1,000 jobs |
|------|---------------|-----------------------|
| Free | $0.00109 | **$1.09** |
| Bronze | $0.00099 | **$0.99** |
| Silver | $0.00089 | **$0.89** |
| Gold | $0.00079 | **$0.79** |

Scraping 1,000 jobs on the Free plan costs about **$1.09**. Your monthly Apify platform credits typically cover several thousand jobs on top of that.

### How it works

1. The Actor builds a Jora search URL from your keyword, location, country, and posted-date filter — or uses your **Start URL** directly.
2. It requests each search results page and parses every job card for title, company, location, salary, job type, posting date, sponsorship flag, and job ID.
3. It stops paginating once `results_wanted` is reached, `max_pages` is hit, or Jora returns no further new results.
4. For each collected job, it opens the job's own detail page to extract the complete description as both plain text and HTML.
5. Jobs are pushed to the dataset page by page, so partial results are available even on a long run.

### Using the Actor via API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("parsebird/jora-jobs-scraper").call(run_input={
    "keyword": "data analyst",
    "country": "Singapore",
    "posted_date": "7d",
    "results_wanted": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], "—", item.get("company"), "—", item.get("salary"))
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('parsebird/jora-jobs-scraper').call({
    keyword: 'software engineer',
    location: 'Melbourne',
    results_wanted: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

The Actor runs on the [Apify platform](https://apify.com), so you also get [scheduling](https://docs.apify.com/platform/schedules), a full [REST API](https://docs.apify.com/api/v2), webhooks, and native integrations with Make, Zapier, Google Sheets, and Slack. Results export as JSON, CSV, Excel, XML, or RSS.

### Use cases

- **Job market research** — track how many roles for a given title are posted across Australia, New Zealand, and Southeast Asia.
- **Recruiting and sourcing** — pull fresh, structured listings for a role or region into an ATS or spreadsheet.
- **Salary benchmarking** — collect the salary lines Jora exposes across job types and locations.
- **Competitor monitoring** — watch a company's or industry's hiring activity over time with scheduled runs.
- **Job aggregation** — feed a niche job board or newsletter with structured Jora listings.

### FAQ

**Do I need a Jora account?**
No. The Actor reads only public job listings. You need an Apify account to run it.

**Why is a residential proxy required?**
Jora is behind Cloudflare and blocks Apify's default datacenter proxy outright. The Actor ships with a residential proxy preset and automatically rotates sessions if one is blocked, so you don't need to configure anything.

**Which countries does this Actor support?**
Australia (au.jora.com), New Zealand (nz.jora.com), Singapore (sg.jora.com), Hong Kong (hk.jora.com), Malaysia (my.jora.com), and Indonesia (id.jora.com).

**Why is salary or job type empty for some jobs?**
Jora only shows a salary badge when the employer or listing source provided one, and only shows a job-type badge when it's stated. Both fields are `null` when Jora itself doesn't display them.

**Can I use a Jora search URL I already built in my browser?**
Yes. Paste it into **Start URL** — the Actor keeps your filters and only adds pagination and the posted-date filter on top.

**Can I schedule recurring runs?**
Yes. Use Apify's [scheduler](https://docs.apify.com/platform/schedules) to run this Actor daily or weekly and export new results automatically. Found a problem? Open an issue on the **Issues** tab.

### Related Actors

- [Indeed Jobs Scraper](https://apify.com/parsebird/indeed-jobs-scraper) — job listings and company data from 60+ Indeed editions.
- [Job Bank Canada Scraper](https://apify.com/parsebird/jobbank-canada-scraper) — Canadian government job board with LMIA status.
- [Jobs.ie Scraper](https://apify.com/parsebird/jobs-ie-scraper) — Irish job listings from Jobs.ie.
- Browse the full [ParseBird publisher page](https://apify.com/parsebird) for more scrapers.

### Legal and compliance

This Actor collects only publicly available job listings from Jora — data any visitor can view without logging in. It does not access private data or bypass authentication. You are responsible for using the scraped data lawfully, including respecting each country's privacy laws (such as Australia's Privacy Act or GDPR where relevant) and any purpose limitations that apply to personal data. Do not use the output to spam candidates or employers. If you plan to scrape at scale or redistribute the data commercially, seek legal advice first. See Apify's guide on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/jora-jobs-scraper/changelog.md

# Actor input Schema

## `startUrl` (type: `string`):

A public Jora search URL (e.g. `https://au.jora.com/j?sp=search&q=software+engineer&l=Melbourne`) to use as the starting point. Overrides Keyword, Location, and Country below when set.

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

Job title, skill, or phrase to search for when Start URL is empty. Leave blank for an unfiltered search.

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

City, region, or other location filter. Leave empty for a broader search.

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

Jora site to search when Start URL is empty.

## `posted_date` (type: `string`):

Only return jobs posted within this time frame.

## `results_wanted` (type: `integer`):

Maximum number of jobs to save.

## `max_pages` (type: `integer`):

Maximum number of search result pages to process.

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

Jora blocks Apify's default datacenter proxy, so residential routing is preset. Change it only for an account-specific setup.

## Actor input object example

```json
{
  "keyword": "software engineer",
  "location": "Sydney",
  "country": "Australia",
  "posted_date": "anytime",
  "results_wanted": 20,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrl": "",
    "keyword": "software engineer",
    "location": "Sydney",
    "results_wanted": 20,
    "max_pages": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/jora-jobs-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 = {
    "startUrl": "",
    "keyword": "software engineer",
    "location": "Sydney",
    "results_wanted": 20,
    "max_pages": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/jora-jobs-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 '{
  "startUrl": "",
  "keyword": "software engineer",
  "location": "Sydney",
  "results_wanted": 20,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parsebird/jora-jobs-scraper --silent --output-dataset

```

## MCP server setup

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