# Jora Jobs Extractor (`kawsar/jora-jobs-extractor`) Actor

Pulls job title, company, salary, location and posting date from Jora search results, so you can track hiring trends without copying listings by hand.

- **URL**: https://apify.com/kawsar/jora-jobs-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Jora Jobs Extractor

Jora Jobs Extractor pulls job listings off Jora by keyword and location, giving you job title, company, salary, location, job type, posting date, and a direct link for every matching role. Instead of scrolling through search results and copying data by hand, you get a structured dataset ready for a spreadsheet, dashboard, or hiring-trend report.

### Why use this actor

Jora aggregates listings from thousands of employers and job boards, which makes it a useful signal for hiring activity, salary ranges, and role demand across a market. Pulling that data by hand is slow and easy to get wrong. This actor automates the search, pagination, and field extraction so you get consistent, structured records every run.

- **No coding required** — set your search terms in the input form and run
- **Automatic pagination** — walks through result pages until it hits your item limit or runs out of listings
- **Regional coverage** — search Jora's Australian site or other regional Jora domains
- **Deduplication** — listings are deduplicated by URL within a run
- **Per-item resilience** — a parsing miss on one listing does not stop the rest of the run

### What data it extracts

For every job listing found, the actor captures:

| Field | Description |
|---|---|
| Job title | The title of the role as listed |
| Company name | The hiring company or agency |
| Location | City, region, or area listed for the role |
| Salary | Salary or pay range, when Jora shows one |
| Job snippet | Short preview text from the listing |
| Job URL | Direct link to the full listing on Jora |
| Date posted | How recently the listing was posted |
| Job type | Full-time, part-time, casual, contract, etc., when available |
| Listing ID | Jora's internal identifier for the listing |
| Search query | The keyword used for that run |
| Search location | The location filter used for that run |
| Scraped at | UTC timestamp of when the record was collected |

### How to use it

1. Open the actor and enter a **search keyword**, such as `software engineer` or `data analyst`.
2. Optionally add a **location**, like `Sydney, NSW`.
3. Pick a **Jora domain** if you are searching outside Australia.
4. Set **max items** to control how many listings the run collects (default is 10).
5. Click **Start** and open the dataset once the run finishes.

You can also run it via the Apify API, CLI, or one of the client SDKs (Python, JavaScript) if you want to plug it into an existing pipeline.

#### Input example

```json
{
  "query": "software engineer",
  "location": "Sydney, NSW",
  "joraDomain": "au.jora.com",
  "maxItems": 10
}
```

#### Output example

```json
{
  "jobTitle": "Senior Software Engineer",
  "companyName": "Acme Technologies",
  "location": "Sydney NSW",
  "salary": "$120,000 - $150,000 a year",
  "jobSnippet": "We are looking for an experienced software engineer to join our growing team...",
  "jobUrl": "https://au.jora.com/job/senior-software-engineer-abc123",
  "datePosted": "3 days ago",
  "jobType": "Full time",
  "listingId": "abc123",
  "searchQuery": "software engineer",
  "searchLocation": "Sydney, NSW",
  "scrapedAt": "2026-08-18T09:15:00.000Z"
}
```

### Input parameters

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `query` | String | Yes | — | Search keyword, job title, or skill |
| `location` | String | No | — | City, region, or state to search in |
| `joraDomain` | String | No | `au.jora.com` | Regional Jora site to search |
| `maxItems` | Integer | No | `10` | Maximum number of listings to extract per run (max 1000) |
| `requestTimeoutSecs` | Integer | No | `30` | Per-request timeout in seconds |

### Output

Results are stored in the actor's dataset, one item per job listing. From the Apify Console you can export the dataset as JSON, CSV, Excel, XML, or HTML, or pull it programmatically through the Apify API.

### Who it's for

- **Recruiters and staffing agencies** tracking open roles across a region or industry
- **Job boards and aggregators** mirroring or supplementing their own listings
- **Market researchers and analysts** studying salary bands and hiring trends
- **SEO and content teams** building job-market pages or reports

### Tips for better results

- Broader keywords return more listings; narrow keywords return fewer but more relevant ones.
- Leave location blank to search all locations within the selected Jora domain.
- Raise `maxItems` if you need full market coverage rather than a quick sample; lower it for fast, cheap test runs.

### FAQ

**Does this work outside Australia?**
Yes. Use the `joraDomain` input to switch between supported regional Jora sites.

**What happens if a listing is missing a field, like salary?**
Fields that Jora does not show for a given listing, such as salary, are returned as `null` rather than causing the run to fail.

**Can I run this on a schedule?**
Yes. Apify supports scheduled runs, so you can track new listings for a search term over time and compare dataset snapshots.

# Actor input Schema

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

Job title, skill, or keyword to search for on Jora.

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

City, region, or state to search in. Leave blank to search all locations.

## `joraDomain` (type: `string`):

Regional Jora site to search.

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

Maximum number of job listings to extract per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "query": "software engineer",
  "location": "Sydney, NSW",
  "joraDomain": "au.jora.com",
  "maxItems": 10,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `properties` (type: `string`):

Extract job listings from Jora search results including title, company, location, salary, job type, and posting date.

# 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 = {
    "query": "software engineer",
    "location": "Sydney, NSW"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/jora-jobs-extractor").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 = {
    "query": "software engineer",
    "location": "Sydney, NSW",
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/jora-jobs-extractor").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 '{
  "query": "software engineer",
  "location": "Sydney, NSW"
}' |
apify call kawsar/jora-jobs-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/jora-jobs-extractor"
        }
    }
}

```

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/HYwc6O5gtfLO475fm/builds/Qo3mdJYm79FISCium/openapi.json