# Jobstreet/JobsDB Scrapper (`mae_fox/jobstreet-jobsdb-scrapper`) Actor

A high-performance Actor that scrapes job listings from JobStreet and JobsDB across multiple Southeast Asian and Oceanic regions using native REST APIs. Extract structured job data including titles, companies, locations, salaries, and descriptions.

- **URL**: https://apify.com/mae\_fox/jobstreet-jobsdb-scrapper.md
- **Developed by:** [Rifqi Edrial](https://apify.com/mae_fox) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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/docs.md):

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

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

## JobStreet & JobsDB Jobs Scraper

A high-performance Apify Actor that scrapes job listings from JobStreet and JobsDB across multiple Southeast Asian and Oceanic regions using native REST APIs. Extract structured job data including titles, companies, locations, salaries, and descriptions without dealing with HTML parsing or anti-scraping mechanisms.

---

### 🚀 Features

- **Multi-Region Support**: Scrape jobs from 8 countries across Southeast Asia and Oceania
- **Native API Integration**: Uses JobStreet/JobsDB's official REST API endpoints for reliable, structured data
- **Smart Pagination**: Automatically handles multi-page results with configurable limits
- **Rich Job Data**: Extracts 10+ fields including salary, work type, posted date, and job descriptions
- **Zero HTML Parsing**: Direct JSON responses eliminate fragility and maintenance overhead
- **Apify SDK Integration**: Stores results in Apify datasets for easy export and integration
- **Configurable Inputs**: Flexible search by keyword, location, and regional site

---

### 🌏 Supported Regions

The scraper supports the following regional job boards:

| Region | Site Key | Domain | Job Board |
|--------|----------|--------|-----------|
| 🇲🇾 Malaysia | `MY-Main` | my.jobstreet.com | JobStreet Malaysia |
| 🇸🇬 Singapore | `SG-Main` | sg.jobstreet.com | JobStreet Singapore |
| 🇵🇭 Philippines | `PH-Main` | ph.jobstreet.com | JobStreet Philippines |
| 🇮🇩 Indonesia | `ID-Main` | id.jobstreet.com | JobStreet Indonesia |
| 🇹🇭 Thailand | `TH-Main` | th.jobsdb.com | JobsDB Thailand |
| 🇭🇰 Hong Kong | `HK-Main` | hk.jobsdb.com | JobsDB Hong Kong |
| 🇦🇺 Australia | `AU-Main` | au.jobstreet.com | JobStreet Australia |
| 🇳🇿 New Zealand | `NZ-Main` | nz.jobstreet.com | JobStreet New Zealand |

---

### 📋 Input Configuration

The scraper accepts the following input parameters via JSON configuration:

#### Input Schema

```json
{
  "keyword": "python developer",
  "siteKey": "SG-Main",
  "where": "Singapore",
  "maxItems": 50
}
````

#### Parameter Details

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keyword` | String | ✅ Yes | `"python"` | Job title, skills, or keywords to search for |
| `siteKey` | String | ✅ Yes | `"SG-Main"` | Regional site identifier (see Supported Regions table) |
| `where` | String | ❌ No | `""` | Location filter (city, region, or leave empty for all) |
| `maxItems` | Integer | ❌ No | `50` | Maximum number of jobs to scrape (increments of 20) |

#### Example Configurations

**Search for Data Scientists in Malaysia:**

```json
{
  "keyword": "data scientist",
  "siteKey": "MY-Main",
  "where": "Kuala Lumpur",
  "maxItems": 100
}
```

**Search for Full Stack Developers in Singapore:**

```json
{
  "keyword": "full stack developer",
  "siteKey": "SG-Main",
  "where": "",
  "maxItems": 200
}
```

**Search for Marketing Managers in Hong Kong:**

```json
{
  "keyword": "marketing manager",
  "siteKey": "HK-Main",
  "where": "Central",
  "maxItems": 50
}
```

***

### 📤 Output Format

The scraper outputs structured JSON data with the following fields for each job:

#### Output Schema

```json
{
  "id": "93390855",
  "title": "Python Quant Developer-Commodities Trading",
  "company": "Pinpoint Asia Limited",
  "location": "Central Region",
  "jobUrl": "https://sg.jobstreet.com/job/93390855",
  "postedDate": "2026-07-17",
  "postedDateDisplay": "8h ago",
  "salary": "$200,000 per year",
  "workType": "Full time",
  "workArrangement": "Hybrid",
  "teaser": "You will work directly alongside portfolio managers...",
  "bulletPoints": [
    "High-impact role bridging quantitative research and Python development.",
    "Join a leading global buy-side firm on a high-growth commodities desk."
  ]
}
```

#### Field Descriptions

| Field | Type | Description |
|-------|------|-------------|
| `id` | String | Unique job posting identifier |
| `title` | String | Job title |
| `company` | String | Hiring company name |
| `location` | String | Job location (city/region) |
| `jobUrl` | String | Direct link to full job posting |
| `postedDate` | String | ISO date when job was posted |
| `postedDateDisplay` | String | Human-readable posted time (e.g., "2 days ago") |
| `salary` | String | Salary information (if available, empty string otherwise) |
| `workType` | String | Employment type (Full time, Part time, Contract, etc.) |
| `workArrangement` | String | Work arrangement (Remote, Hybrid, On-site, etc.) |
| `teaser` | String | Short job description or summary |
| `bulletPoints` | Array | Key highlights or selling points of the role |

***

#### Running on Apify Platform

1. Navigate to your actor in the Apify Console
2. Click **"Input"** tab
3. Configure your search parameters
4. Click **"Start"** to run
5. Download results from the **"Storage"** → **"Dataset"** tab

***

### 💡 Use Cases

- **Job Market Research**: Analyze salary trends, in-demand skills, and hiring patterns
- **Talent Acquisition**: Monitor competitor hiring and discover candidate pools
- **Career Planning**: Track job availability and requirements in target industries
- **Data Analysis**: Build datasets for ML models, trend analysis, or visualization
- **Lead Generation**: Identify companies actively hiring in specific sectors

***

### 🔧 Troubleshooting

#### No Results Returned

- **Check keyword spelling**: Ensure your search term is spelled correctly
- **Try broader keywords**: "software" instead of "senior principal staff software architect"
- **Verify siteKey**: Ensure you're using a valid regional site key from the Supported Regions table
- **Check location filter**: Try removing the `where` parameter or using a broader location

#### Timeout Errors

- **Reduce maxItems**: Lower the `maxItems` value to retrieve fewer results
- **Network issues**: Verify your internet connection is stable

#### Incomplete Data Fields

- **Salary field empty**: Not all job postings include salary information
- **bulletPoints array empty**: Some listings don't provide structured highlights

***

### 📝 Notes

- **Rate Limiting**: The scraper respects reasonable rate limits. For high-volume scraping, consider adding delays between requests.
- **Data Freshness**: Job listings are scraped in real-time from the live API.
- **API Changes**: If JobStreet/JobsDB updates their API, the scraper may require maintenance.

***

### 📜 License

This actor is provided as-is for data collection and analysis purposes. Ensure your usage complies with JobStreet and JobsDB's Terms of Service.

***

### 🤝 Support

For issues, questions, or feature requests:

- Review the Troubleshooting section above
- Check Apify documentation: https://docs.apify.com
- Review actor logs for detailed error messages

***

**Built with [Apify SDK](https://sdk.apify.com/) • Powered by JobStreet & JobsDB APIs**

# Actor input Schema

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

Job title or keyword to search

## `siteKey` (type: `string`):

Site key targeting a regional job board

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

Specific location or region (optional)

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

Max job postings to scrape

## Actor input object example

```json
{
  "keyword": "python",
  "siteKey": "SG-Main",
  "maxItems": 50
}
```

# 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 = {
    "keyword": "python",
    "siteKey": "SG-Main",
    "where": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("mae_fox/jobstreet-jobsdb-scrapper").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 = {
    "keyword": "python",
    "siteKey": "SG-Main",
    "where": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("mae_fox/jobstreet-jobsdb-scrapper").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 '{
  "keyword": "python",
  "siteKey": "SG-Main",
  "where": "",
  "maxItems": 50
}' |
apify call mae_fox/jobstreet-jobsdb-scrapper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobstreet/JobsDB Scrapper",
        "description": "A high-performance Actor that scrapes job listings from JobStreet and JobsDB across multiple Southeast Asian and Oceanic regions using native REST APIs. Extract structured job data including titles, companies, locations, salaries, and descriptions.",
        "version": "0.0",
        "x-build-id": "yNe8WEaQJjYEVyn8d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mae_fox~jobstreet-jobsdb-scrapper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mae_fox-jobstreet-jobsdb-scrapper",
                "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/mae_fox~jobstreet-jobsdb-scrapper/runs": {
            "post": {
                "operationId": "runs-sync-mae_fox-jobstreet-jobsdb-scrapper",
                "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/mae_fox~jobstreet-jobsdb-scrapper/run-sync": {
            "post": {
                "operationId": "run-sync-mae_fox-jobstreet-jobsdb-scrapper",
                "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",
                "required": [
                    "keyword",
                    "siteKey"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job title or keyword to search"
                    },
                    "siteKey": {
                        "title": "Regional Site Key",
                        "enum": [
                            "MY-Main",
                            "SG-Main",
                            "PH-Main",
                            "ID-Main",
                            "TH-Main",
                            "HK-Main",
                            "AU-Main",
                            "NZ-Main"
                        ],
                        "type": "string",
                        "description": "Site key targeting a regional job board"
                    },
                    "where": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Specific location or region (optional)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Max job postings to scrape"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
