# Jobsdb Jobs Search Scraper (`soft_alexist/jobsdb-jobs-search-scraper`) Actor

Scrape job search results from JobsDB.com with precision. Extract company names, salaries, locations, work types, and 20+ fields from search result pages — perfect for job aggregators, market analysis, and recruitment research.

- **URL**: https://apify.com/soft\_alexist/jobsdb-jobs-search-scraper.md
- **Developed by:** [Soft Alexist](https://apify.com/soft_alexist) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## JobsDB Jobs Search Scraper: Harvest Career Listings at Scale

---

### What Is JobsDB?

JobsDB is one of Asia-Pacific's largest job search platforms, hosting millions of active listings across technology, finance, healthcare, and general employment categories. The platform spans multiple regions, including Hong Kong, Singapore, Philippines, and Thailand. Scraping JobsDB search results enables recruiters, researchers, and analysts to capture job market intelligence, track hiring trends, and build competitive datasets — tasks that manual copying would take weeks to complete.

---

### Overview

The **JobsDB Jobs Search Scraper** extracts structured job listings directly from JobsDB search result pages (not individual detail pages). It transforms unstructured HTML into clean, queryable records with 20+ fields per job. This scraper is built for:

- **Job aggregators** combining listings from multiple sources into a unified platform
- **Recruitment agencies** monitoring competitor postings and market gaps
- **Data analysts** studying employment trends, salary distributions, and hiring demand
- **HR teams** benchmarking roles, responsibilities, and compensation across regions

The scraper handles pagination intelligently, allows bulk URL processing, and includes error resilience through the `ignore_url_failures` flag.

---

### Input Configuration

The scraper accepts a JSON configuration object tailored for search result pages:

```json
{
  "urls": [
    "https://hk.jobsdb.com/Software-Engineer-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Configuration Parameters

| Parameter | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | Links to JobsDB job search result pages (not individual job detail pages) | `["https://hk.jobsdb.com/Software-Engineer-jobs"]` |
| `max_items_per_url` | Integer | Maximum number of job listings to extract per search URL | `200` |
| `ignore_url_failures` | Boolean | If `true`, skips failed URLs and continues scraping. If `false`, stops on first error | `true` |

> **Best practice:** Use search URLs filtered by job title, location, or category. For example: `https://[region].jobsdb.com/[Job-Title]-jobs` or add filters like `&salary=` for refined results.

***

### Output Format: 20+ Structured Fields

**Sample output**

```json
{
  "advertiser": {
    "__typename": "JobSearchV6Advertiser",
    "id": "61337487",
    "description": "Virtual Gaming Technology Limited"
  },
  "branding": {
    "__typename": "JobSearchV6Branding",
    "serp_logo_url": "https://bx-branding-gateway.cloud.seek.com.au/d6256ec0-1c34-4c80-8e68-68583970aafe.1/jdpLogo"
  },
  "bullet_points": [
    "Attractive remuneration package with Flexible working hours",
    "5-day work week, 14 days Annual Leave + Birthday Leave",
    "5+ years software engineering, 3+ in backend."
  ],
  "classifications": [
    {
      "__typename": "JobSearchV6Classification",
      "classification": {
        "__typename": "JobSearchV6ClassificationDetail",
        "id": "6281",
        "description": "Information & Communication Technology"
      },
      "subclassification": {
        "__typename": "JobSearchV6ClassificationDetail",
        "id": "6290",
        "description": "Engineering - Software"
      }
    }
  ],
  "company_name": "Virtual Gaming Technology Limited",
  "currency_label": null,
  "display_type": "standard",
  "employer": {
    "__typename": "JobSearchV6Employer",
    "company_url": "https://hk.jobsdb.com/companies/virtual-gaming-technology-limited-171089885763940",
    "relative_company_url": "/companies/virtual-gaming-technology-limited-171089885763940",
    "zone": "asia-1"
  },
  "external_references": null,
  "id": "93238491",
  "is_featured": false,
  "locations": [
    {
      "__typename": "JobSearchV6DataLocation",
      "country_code": "HK",
      "label": "Tsim Sha Tsui, Yau Tsim Mong District",
      "seo_hierarchy": [
        {
          "__typename": "JobSearchV6SeoHierarchy",
          "contextual_name": "Tsim Sha Tsui Yau Tsim Mong District"
        },
        {
          "__typename": "JobSearchV6SeoHierarchy",
          "contextual_name": "Yau Tsim Mong District"
        }
      ]
    }
  ],
  "role_id": "Artificial-Intelligence-Engineer",
  "salary_label": "",
  "sol_metadata": {
    "search_request_token": "97bf36fc-9c7f-414e-a617-76096d78fc04",
    "token": "0~97bf36fc-9c7f-414e-a617-76096d78fc04",
    "job_id": "93238491",
    "section": "MAIN",
    "section_rank": 2,
    "job_ad_type": "ORGANIC",
    "tags": {
      "mordor__flights": "mordor_523",
      "mordor__s": "0"
    }
  },
  "tags": [],
  "teaser": "AI-focused backend engineer building scalable, production-ready AI features.",
  "title": "Senior Software Engineer - AI",
  "tracking": "ewogICJ0b2tlbiI6ICI0NWVjN2VmNi0xMGU3LTRlMWItODExMy02NzY3YmUzNmJmMDZfMiIKfQ==",
  "work_arrangements": {
    "__typename": "JobSearchV6WorkArrangements",
    "display_text": null
  },
  "work_types": [
    "Full time"
  ],
  "listing_date": "2026-07-10T01:38:04.000Z",
  "listing_date_display": "4h ago",
  "company_profile_structured_data_id": 408641,
  "from_url": "https://hk.jobsdb.com/Software-Engineer-jobs"
}
```

Each job record extracted from search results includes:

#### Core Job Information

| Field | Purpose |
|---|---|
| `id` | Unique JobsDB identifier for this listing |
| `role_id` | Internal role classification ID |
| `title` | Job title displayed in the search result |
| `teaser` | Short preview or snippet of the job posting |
| `company_name` | Employer name |
| `employer` | Detailed employer metadata and profile info |
| `advertiser` | Account or advertiser who posted the job |

#### Compensation & Benefits

| Field | Purpose |
|---|---|
| `salary_label` | Displayed salary range (e.g., "SGD 4,000 - 6,000") |
| `currency_label` | Currency code (e.g., "SGD", "HKD", "PHP") |
| `bullet_points` | Key benefits, perks, or highlights listed by the employer |

#### Job Details & Categorization

| Field | Purpose |
|---|---|
| `locations` | Work location(s) — typically city and country |
| `classifications` | Job category tags (e.g., "Technology", "Engineering") |
| `work_types` | Employment type (e.g., permanent, contract, temporary, internship) |
| `work_arrangements` | Work mode (e.g., on-site, remote, hybrid) |
| `tags` | Additional searchable keywords or attributes |

#### Posting & Display Attributes

| Field | Purpose |
|---|---|
| `listing_date` | Date the job was posted (timestamp format) |
| `listing_date_display` | Human-readable publication date (e.g., "Posted 2 days ago") |
| `is_featured` | Boolean flag — whether the listing has paid featured placement |
| `display_type` | How the job is displayed (featured, standard, etc.) |
| `branding` | Company branding elements (logo, colors, styling) |
| `external_references` | Links to external job postings or company sites |
| `tracking` | Analytics and tracking codes for click attribution |
| `sol_metadata` | Structured metadata for search optimization |
| `company_profile_structured_data_id` | Linked company profile identifier |

***

### How to Use

**Step 1: Identify Search URLs**
Navigate to JobsDB in your target region (e.g., `hk.jobsdb.com`, `sg.jobsdb.com`) and perform a job search. Copy the full URL from the address bar. Examples:

- `https://hk.jobsdb.com/Software-Engineer-jobs`
- `https://sg.jobsdb.com/Data-Scientist-jobs?salary=5000-9000`

**Step 2: Configure the Scraper**
Paste URLs into the `urls` array. Set `max_items_per_url` based on how many results you need per search (typically 20–200).

**Step 3: Run the Scraper**
Execute the scraper and monitor progress. The `ignore_url_failures: true` setting ensures continued operation if a URL fails.

**Step 4: Export Data**
Download results as JSON, CSV, or Excel for analysis, database import, or platform integration.

#### Usage Tips

- **Multi-region scraping:** Add URLs from different JobsDB regions in one run (e.g., Hong Kong and Singapore).
- **Incremental runs:** Scrape the same URL periodically to track new postings and removed listings.
- **Filter by keyword:** Adjust search URLs to include salary ranges, job levels, or experience filters for refined datasets.
- **Handling pagination:** The scraper automatically processes paginated results up to `max_items_per_url`.

***

### Business Use Cases & Value

**Job Aggregation Platforms**
Combine JobsDB listings with other sources to build a unified job search experience.

**Talent Market Intelligence**
Analyze salary trends, in-demand skills, and geographic hiring patterns across Asia-Pacific regions.

**Recruitment & HR Analytics**
Monitor competitor hiring, identify talent hotspots, and benchmark compensation for negotiation.

**Academic & Economic Research**
Study labor market dynamics, employment type preferences, and sectoral hiring shifts over time.

The JobsDB Jobs Search Scraper delivers the data infrastructure behind these use cases, replacing manual effort with automated, scalable collection.

***

### Conclusion

The **JobsDB Jobs Search Scraper** is the essential tool for anyone needing large-scale job market data. With 20+ fields per listing, multi-regional support, and robust error handling, it transforms JobsDB search results into clean, actionable intelligence. Start scraping today and unlock insights that drive recruitment, investment, and policy decisions.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://hk.jobsdb.com/Software-Engineer-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://hk.jobsdb.com/Software-Engineer-jobs"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("soft_alexist/jobsdb-jobs-search-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 = {
    "urls": ["https://hk.jobsdb.com/Software-Engineer-jobs"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("soft_alexist/jobsdb-jobs-search-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 '{
  "urls": [
    "https://hk.jobsdb.com/Software-Engineer-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call soft_alexist/jobsdb-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobsdb Jobs Search Scraper",
        "description": "Scrape job search results from JobsDB.com with precision. Extract company names, salaries, locations, work types, and 20+ fields from search result pages — perfect for job aggregators, market analysis, and recruitment research.",
        "version": "0.0",
        "x-build-id": "CIMTGaPefIxbC9fmI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/soft_alexist~jobsdb-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-soft_alexist-jobsdb-jobs-search-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/soft_alexist~jobsdb-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-soft_alexist-jobsdb-jobs-search-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/soft_alexist~jobsdb-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-soft_alexist-jobsdb-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
