# JobStreet Singapore Jobs Scraper (`automation-lab/jobstreet-singapore-jobs-scraper`) Actor

Extract public JobStreet Singapore vacancies with employer, salary, location, work arrangement, classification, listing date, description, and canonical URL data. Export to JSON, CSV, or Excel and schedule recurring searches.

- **URL**: https://apify.com/automation-lab/jobstreet-singapore-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Singapore Jobs Scraper

Collect fresh **JobStreet Singapore job listings** without a login or API key.
Search by role, skill, employer keyword, location, classification, work type, salary availability, or listing age.
Export clean vacancy data to JSON, CSV, Excel, XML, or RSS for recruiting and labour-market workflows.

- 🔎 Search multiple roles in one run.
- 💰 Capture published salary labels and parsed salary ranges.
- 🏢 Identify employers that are actively hiring.
- 📍 Compare vacancies across Singapore locations.
- ⏱️ Sort newest first and schedule recurring searches.

[Try JobStreet Singapore Jobs Scraper on Apify](https://apify.com/automation-lab/jobstreet-singapore-jobs-scraper).

### What does JobStreet Singapore Jobs Scraper do?

JobStreet Singapore Jobs Scraper extracts public vacancy cards from [sg.jobstreet.com](https://sg.jobstreet.com).
It turns changing search pages into a stable dataset with job IDs, titles, employers, salary signals, work arrangements, classifications, dates, descriptions, and canonical links.

The Actor is explicitly **Singapore-only**.
It does not silently mix Malaysia, Indonesia, the Philippines, or other SEEK markets into your results.
No JobStreet account, employer account, private credential, or paid API is required.

The extractor uses JobStreet's public structured search surface instead of rendering a heavy browser for every page.
That makes scheduled searches faster and keeps platform costs predictable.

### Who is this JobStreet jobs scraper for?

**Recruiters and staffing teams**

- Build role-specific candidate sourcing lists from current openings.
- Discover employers with fresh hiring demand.
- Track contract, full-time, part-time, hybrid, remote, or on-site demand.

**Sales and lead-generation teams**

- Treat a new vacancy as a verified hiring-intent signal.
- Route employers to HR software, payroll, staffing, training, or IT-service campaigns.
- Export company names and vacancy context to a CRM enrichment workflow.

**Job aggregators and newsletter operators**

- Collect canonical JobStreet links for a Singapore niche board.
- Power daily or weekly vacancy newsletters.
- Deduplicate feeds with the stable `jobId` field.

**Labour-market and compensation analysts**

- Compare published salary ranges by role and classification.
- Measure location and work-arrangement trends.
- Monitor listing velocity with newest-first scheduled searches.

### Why use this Actor?

- ✅ **Live source data** — records come from JobStreet Singapore's current search index.
- ✅ **No login** — no account, cookies, or private token to maintain.
- ✅ **Singapore scope** — every canonical URL uses `sg.jobstreet.com`.
- ✅ **Structured salaries** — keep the original label plus numeric min/max when parseable.
- ✅ **Source taxonomy** — retain JobStreet classification and subclassification IDs.
- ✅ **Low overhead** — structured requests avoid browser rendering.
- ✅ **Streaming output** — jobs appear in the dataset as they are found.
- ✅ **Automation ready** — use schedules, webhooks, API clients, Make, Zapier, or MCP.

### What JobStreet Singapore data can you extract?

| Data group | Fields | Example |
|---|---|---|
| Identity | `jobId`, `title`, `url`, `roleId` | Software Engineer |
| Employer | `companyName`, `companyId` | Example Pte Ltd |
| Location | `location`, `country`, `searchLocation` | Central Region, Singapore |
| Salary | `salaryLabel`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | $4,000–$5,500 per month |
| Work | `workTypes`, `workArrangements` | Full time, Hybrid |
| Taxonomy | `classification`, `subClassification`, IDs | ICT, Engineering - Software |
| Freshness | `listingDate`, `listingAge`, `scrapedAt` | 2026-07-17T08:00:00Z |
| Content | `description`, `bulletPoints`, `tags` | Public search-card summary |
| Advertising | `isFeatured`, `jobAdType` | false, ORGANIC |
| Traceability | `searchTerm`, `searchLocation` | data engineer, Jurong |

JobStreet fields are employer-entered.
Some employers do not publish a salary, work arrangement, highlight, or company identifier.
The Actor preserves available data and does not invent missing values.

### How much does it cost to scrape JobStreet Singapore jobs?

This Actor uses **pay-per-event** pricing.
A small start event covers setup, then each unique saved vacancy is charged once.
Apify platform usage is included in the event price.

| Charge | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Run start | $0.005 | $0.005 | $0.005 | $0.005 |
| Per saved job | $0.00003466 | $0.000030139 | $0.000023509 | $0.000018084 |
| 1,000 jobs plus start | $0.03966 | $0.03514 | $0.02851 | $0.02308 |

Platinum and Diamond plans receive additional volume discounts.
Final live prices are shown in the Apify Console before every run.
With Apify's free monthly credits, you can test a small targeted search before scaling.

### How to scrape JobStreet Singapore jobs

1. Open [JobStreet Singapore Jobs Scraper](https://apify.com/automation-lab/jobstreet-singapore-jobs-scraper).
2. Enter one or more roles, skills, or employer keywords in **Search terms**.
3. Optionally add Singapore locations or numeric JobStreet classification IDs.
4. Choose newest-first or keyword relevance ordering.
5. Set a small **Maximum jobs** value for your first run.
6. Click **Start** and inspect results in the Dataset tab.
7. Export the dataset or connect it to your downstream workflow.

A small role search:

```json
{
  "searchTerms": ["software engineer"],
  "maxItems": 25,
  "sortBy": "ListedDate"
}
````

A salary research search:

```json
{
  "searchTerms": ["data engineer"],
  "classificationIds": ["6281"],
  "onlyWithSalary": true,
  "maxItems": 100
}
```

A fresh-vacancy search:

```json
{
  "searchTerms": ["accountant", "finance manager"],
  "locations": ["Central Region"],
  "postedWithinDays": 3,
  "sortBy": "ListedDate",
  "maxItems": 250
}
```

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---|---|
| `searchTerms` | string\[] | `["software engineer"]` | Job titles, skills, or employer keywords; 1–20 values |
| `locations` | string\[] | `[]` | Optional Singapore location text; up to 10 values |
| `classificationIds` | string\[] | `[]` | Numeric JobStreet classification IDs |
| `workTypes` | string\[] | `[]` | Full time, Part time, Contract/Temp, or Casual/Vacation |
| `onlyWithSalary` | boolean | `false` | Keep only jobs with a published salary label |
| `postedWithinDays` | integer | `0` | Keep jobs from the last 0–31 days; 0 means any age |
| `sortBy` | string | `ListedDate` | `ListedDate` or `KeywordRelevance` |
| `maxItems` | integer | `50` | Maximum unique jobs to save; 1–10,000 |

Invalid classification IDs and unsupported work types fail closed with a clear error.
The maximum applies across all search term and location combinations, not separately to each query.

### JobStreet classification IDs

JobStreet uses numeric classifications for broad job families.
For example, `6281` represents Information & Communication Technology in current search responses.
Classifications can change upstream, so keep the human-readable `classification` field in your data warehouse as well as the ID.

Use a classification with a broad keyword when you need sector coverage.
Use a precise keyword without a classification when you need role coverage across sectors.
Combining both is the narrowest option.

### Output example

```json
{
  "jobId": "93403990",
  "title": "R&D AI Software Development Engineer",
  "companyName": "Keysight Technologies Singapore (Sales) Pte. Ltd.",
  "companyId": "61548142",
  "location": "Singapore",
  "country": "Singapore",
  "salaryLabel": "$4,000 – $5,500 per month",
  "salaryMin": 4000,
  "salaryMax": 5500,
  "salaryCurrency": "SGD",
  "salaryPeriod": "month",
  "workTypes": ["Full time"],
  "workArrangements": ["On-site"],
  "classification": "Information & Communication Technology",
  "subClassification": "Engineering - Software",
  "listingDate": "2026-07-17T16:07:11Z",
  "listingAge": "12m ago",
  "description": "Contribute to AI-assisted engineering workflows...",
  "isFeatured": false,
  "searchTerm": "software engineer",
  "url": "https://sg.jobstreet.com/job/93403990",
  "scrapedAt": "2026-07-17T16:20:00.000Z"
}
```

Arrays remain arrays in JSON exports.
CSV and Excel exports flatten them according to Apify's dataset export options.

### Tips for better JobStreet results

- 🎯 Start with one precise role and 10–50 jobs.
- 🕒 Use `ListedDate` with `postedWithinDays` for recurring monitoring.
- 💰 Enable `onlyWithSalary` for cleaner compensation studies.
- 📍 Avoid combining too many terms and locations in one run.
- 🧩 Store `jobId` as your durable deduplication key.
- 🔄 Schedule at a cadence that matches the freshness you need.
- 📊 Keep both the original salary label and parsed numeric fields.
- 🏷️ Use source classifications rather than inferring a sector from title alone.

### Automate fresh vacancy monitoring

Create an Apify Schedule with newest-first sorting and a short listing window.
After each run, compare `jobId` values with your database or use a dataset webhook.
This produces a simple fresh-hiring feed without repeatedly processing old listings downstream.

Example daily monitor input:

```json
{
  "searchTerms": ["cyber security", "cloud engineer"],
  "postedWithinDays": 2,
  "sortBy": "ListedDate",
  "maxItems": 200
}
```

### Integrations

**JobStreet → Google Sheets**

Export new employer and salary records to a sheet for recruiter review.
Add a unique constraint on `jobId` to avoid duplicate rows.

**JobStreet → Slack or Discord**

Use an Apify webhook and Make to post newly discovered vacancies into a role-specific channel.
Include title, company, salary, arrangement, and canonical URL.

**JobStreet → HubSpot or Salesforce**

Treat an employer's fresh vacancy as a hiring-intent signal.
Create or enrich the company record and attach the role context.

**JobStreet → warehouse**

Schedule searches and load JSON results into BigQuery, Snowflake, PostgreSQL, or a lakehouse.
Track listing counts and salary medians over time.

**JobStreet → Zapier or Make**

Trigger routing, email alerts, ATS imports, spreadsheet updates, or internal review queues without writing code.

### Use the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobstreet-singapore-jobs-scraper').call({
  searchTerms: ['data analyst'],
  postedWithinDays: 7,
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jobstreet-singapore-jobs-scraper').call(run_input={
    'searchTerms': ['data analyst'],
    'postedWithinDays': 7,
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~jobstreet-singapore-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["data analyst"],"postedWithinDays":7,"maxItems":100}'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with AI agents via MCP

Connect this Actor to Claude Code with the hosted Apify MCP server:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/jobstreet-singapore-jobs-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/jobstreet-singapore-jobs-scraper"
    }
  }
}
```

Your client will ask you to authenticate with Apify.

**Example prompts:**

- “Use `automation-lab/jobstreet-singapore-jobs-scraper` to find 30 new Singapore data-engineering jobs.”
- “Find JobStreet Singapore cybersecurity roles with published salaries and group them by employer.”
- “Collect fresh hybrid software jobs in Central Region and prepare a recruiter briefing.”

### Data quality and limitations

JobStreet controls source availability and field coverage.
An employer may omit salary, arrangement, highlights, or company metadata.
The `description` field is the public description excerpt shown in JobStreet search results; it is not represented as full job-page HTML.

Salary parsing is conservative.
When a label is unparseable, the original `salaryLabel` remains available and numeric fields are omitted.
The Actor never converts an unknown salary period or currency into a guessed value.

A search that genuinely has no matches succeeds with an empty dataset.
A source request failure is retried and a complete extraction failure exits non-zero.

### Is it legal to scrape JobStreet Singapore?

This Actor collects publicly available job-listing information.
Scraping public data is generally permitted in many jurisdictions, but your use case and location may impose additional obligations.
Review JobStreet's terms, copyright rules, database rights, and applicable privacy law before running at scale.

Do not use the Actor to collect private profiles, bypass authentication, send spam, discriminate in employment, or republish protected content without permission.
Store only the data you need, honour deletion requests where applicable, and use conservative schedules.
You are responsible for ensuring that your use is lawful.

### Frequently asked questions

**Does this Actor need a JobStreet login or API key?**

No. It reads the public Singapore vacancy search surface and requires no JobStreet credentials.

**Does it scrape JobStreet Malaysia or other countries?**

No. Version 1 is intentionally limited to JobStreet Singapore and canonical `sg.jobstreet.com` jobs.

**How fast is it?**

Small searches usually complete in seconds because the Actor does not render a browser.
Runtime grows with the number of search combinations and jobs requested.

**Why is a salary missing?**

Many employers do not publish salary data.
Enable `onlyWithSalary` when your workflow requires a disclosed salary.

**Why are numeric salary fields missing even when `salaryLabel` exists?**

The original label may use an unusual format.
The parser fails closed instead of inventing numbers; use the label for manual or custom parsing.

**Why did my search return no jobs?**

The combination of keyword, location, classification, date, salary, and work type may be too narrow.
Remove one filter at a time and retry with a low limit.

**Can I use the Actor as a monitor?**

Yes. Schedule newest-first searches with a short `postedWithinDays` window and deduplicate downstream by `jobId`.

**How is this different from a generic web scraper?**

The Actor understands JobStreet's fields, Singapore scope, taxonomy, salary labels, work arrangements, pagination, and canonical job IDs.

### Related job scrapers

Build a broader hiring-data workflow with other automation-lab Actors:

- [MyCareersFuture Singapore Jobs Scraper](https://apify.com/automation-lab/mycareersfuture-singapore-jobs-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper)
- [Multi ATS Jobs Scraper](https://apify.com/automation-lab/multi-ats-jobs-scraper)

### Support

If a run fails, open an issue from the Actor's Apify Store page.
Include the run URL, a redacted input example, the expected result, and what happened instead.
Do not include private tokens or personal data.

For reproducible results, first retry with one search term and `maxItems: 10`.
That gives support a bounded case to investigate while protecting your budget.

# Actor input Schema

## `searchTerms` (type: `array`):

Enter job titles, skills, or employer keywords to search on JobStreet Singapore.

## `locations` (type: `array`):

Optionally narrow searches with JobStreet location text, for example Central Region, Jurong, or Tampines.

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

Stop after saving this many unique vacancies across all searches.

## `classificationIds` (type: `array`):

Optionally filter by numeric JobStreet classification IDs, such as 6281 for Information & Communication Technology.

## `workTypes` (type: `array`):

Keep vacancies matching the selected JobStreet work types.

## `onlyWithSalary` (type: `boolean`):

Save only vacancies where the employer published a salary label.

## `postedWithinDays` (type: `integer`):

Limit results to vacancies posted in the last N days. Use 0 for any listing age.

## `sortBy` (type: `string`):

Choose newest vacancies first for monitoring, or JobStreet keyword relevance.

## Actor input object example

```json
{
  "searchTerms": [
    "software engineer"
  ],
  "locations": [
    "Central Region"
  ],
  "maxItems": 10,
  "classificationIds": [
    "6281"
  ],
  "workTypes": [
    "Full time"
  ],
  "onlyWithSalary": false,
  "postedWithinDays": 7,
  "sortBy": "ListedDate"
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerms": [
        "software engineer"
    ],
    "locations": [
        "Central Region"
    ],
    "maxItems": 10,
    "classificationIds": [
        "6281"
    ],
    "workTypes": [
        "Full time"
    ],
    "onlyWithSalary": false,
    "postedWithinDays": 7,
    "sortBy": "ListedDate"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobstreet-singapore-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 = {
    "searchTerms": ["software engineer"],
    "locations": ["Central Region"],
    "maxItems": 10,
    "classificationIds": ["6281"],
    "workTypes": ["Full time"],
    "onlyWithSalary": False,
    "postedWithinDays": 7,
    "sortBy": "ListedDate",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobstreet-singapore-jobs-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 '{
  "searchTerms": [
    "software engineer"
  ],
  "locations": [
    "Central Region"
  ],
  "maxItems": 10,
  "classificationIds": [
    "6281"
  ],
  "workTypes": [
    "Full time"
  ],
  "onlyWithSalary": false,
  "postedWithinDays": 7,
  "sortBy": "ListedDate"
}' |
apify call automation-lab/jobstreet-singapore-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobStreet Singapore Jobs Scraper",
        "description": "Extract public JobStreet Singapore vacancies with employer, salary, location, work arrangement, classification, listing date, description, and canonical URL data. Export to JSON, CSV, or Excel and schedule recurring searches.",
        "version": "0.1",
        "x-build-id": "sQsLk59bzsDl3yPRj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jobstreet-singapore-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jobstreet-singapore-jobs-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/automation-lab~jobstreet-singapore-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jobstreet-singapore-jobs-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/automation-lab~jobstreet-singapore-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jobstreet-singapore-jobs-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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "🔎 Search terms",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Enter job titles, skills, or employer keywords to search on JobStreet Singapore.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "📍 Singapore locations",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Optionally narrow searches with JobStreet location text, for example Central Region, Jurong, or Tampines.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique vacancies across all searches.",
                        "default": 50
                    },
                    "classificationIds": {
                        "title": "JobStreet classification IDs",
                        "type": "array",
                        "description": "Optionally filter by numeric JobStreet classification IDs, such as 6281 for Information & Communication Technology.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "workTypes": {
                        "title": "Work types",
                        "type": "array",
                        "description": "Keep vacancies matching the selected JobStreet work types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Full time",
                                "Part time",
                                "Contract/Temp",
                                "Casual/Vacation"
                            ],
                            "enumTitles": [
                                "Full time",
                                "Part time",
                                "Contract / Temp",
                                "Casual / Vacation"
                            ]
                        },
                        "default": []
                    },
                    "onlyWithSalary": {
                        "title": "Only jobs with salary",
                        "type": "boolean",
                        "description": "Save only vacancies where the employer published a salary label.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 0,
                        "maximum": 31,
                        "type": "integer",
                        "description": "Limit results to vacancies posted in the last N days. Use 0 for any listing age.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "ListedDate",
                            "KeywordRelevance"
                        ],
                        "type": "string",
                        "description": "Choose newest vacancies first for monitoring, or JobStreet keyword relevance.",
                        "default": "ListedDate"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```