# MyCareersFuture Singapore Jobs Scraper (`automation-lab/mycareersfuture-singapore-jobs-scraper`) Actor

Extract public Singapore jobs with salaries, employer UENs, skills, categories, vacancies, locations, dates, and source links. Search, schedule, and export without login.

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

## Pricing

from $0.01 / 1,000 job extracteds

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

## MyCareersFuture Singapore Jobs Scraper

Collect public **Singapore job listings from MyCareersFuture** as clean JSON, CSV, Excel, XML, or RSS data.
Search by title or skill, filter structured records, and export salaries, employer UENs, skills, dates, vacancies, locations, and public job URLs.

The Actor talks directly to the public MyCareersFuture JSON service.
It needs **no login, cookie, browser, proxy, or external API key**.
Start with `software engineer` and ten jobs to review the dataset in under a minute.

### What does MyCareersFuture Singapore Jobs Scraper do?

MyCareersFuture Singapore Jobs Scraper searches and paginates current listings on Singapore's public [MyCareersFuture](https://www.mycareersfuture.gov.sg/) portal.
It turns each listing into one analysis-ready row with normalized text and flattened fields.

Use it to:

- 🔎 search job titles, skills, descriptions, and employers;
- 💰 compare advertised SGD salary ranges;
- 🏢 identify employers by company name and Singapore UEN;
- 🧰 collect skills, categories, seniority, and employment types;
- 📍 map jobs by address, district, region, postal code, and coordinates;
- 📅 monitor posting, update, and expiry dates;
- 🔗 retain the public job page and API record links.

Unlike browser automation, the Actor uses lightweight HTTP requests to the structured source.
That makes scheduled collection fast, stable, and inexpensive.

### Who is it for?

**Recruiters and talent intelligence teams**

- Build daily shortlists for specific roles or skills.
- Compare salary bands across employers and position levels.
- Monitor one employer by UEN for new hiring activity.

**Job boards and aggregators**

- Import normalized listings into a search index.
- Deduplicate updates with stable job UUIDs and MCF post IDs.
- Remove expired records using the published expiry date.

**Labor-market and salary analysts**

- Track vacancy volume by category, district, or seniority.
- Measure salary distributions in SGD.
- Analyze demand for skills and occupations over time.

**Sales and business intelligence teams**

- Detect companies actively hiring.
- Connect employer UENs with internal company records.
- Trigger account alerts from scheduled job-feed changes.

### Why use this MyCareersFuture scraper?

- ✅ **First-party structured data** — no brittle visual page selectors.
- ✅ **Rich Singapore fields** — salary, UEN, SSOC, skills, vacancies, dates, and GPS where published.
- ✅ **No authentication** — no MyCareersFuture account or private credential.
- ✅ **Strict filters** — missing salary or date values do not accidentally pass active filters.
- ✅ **Bounded collection** — control both saved jobs and scanned API pages.
- ✅ **Portable exports** — use Apify datasets in JSON, CSV, Excel, XML, or RSS.
- ✅ **Automation ready** — schedule runs, call the API, send webhooks, or connect Make and Zapier.
- ✅ **Efficient runtime** — direct HTTP at 256 MB, without browser overhead.

### What MyCareersFuture job data can you extract?

| Data group | Example fields |
|---|---|
| Job identity | `uuid`, `jobPostId`, `title`, `status` |
| Description | normalized `description`, optional `descriptionHtml` |
| Employer | `companyName`, `companyUen`, website, logo, employee count |
| Salary | `salaryMinimum`, `salaryMaximum`, `salaryType`, `salaryCurrency` |
| Requirements | skills, key skills, minimum experience, SSOC and occupation IDs |
| Classification | categories, employment types, position levels, schemes |
| Hiring volume | vacancies, view count, application count |
| Location | address, postal code, districts, regions, latitude, longitude |
| Dates | posted, original posted, created, updated, expiry, scraped |
| Links | public `sourceUrl` and structured `apiUrl` |

Optional fields are omitted when the source does not publish them.
Arrays remain arrays, numbers remain numbers, and descriptions are converted from HTML to readable text.

### How much does it cost to scrape MyCareersFuture jobs?

This Actor uses **pay-per-event pricing**.
A run has a small start fee and a price for each job saved successfully.
There is no separate proxy, browser, or API subscription charge.

| Apify plan | Start | Per saved job |
|---|---:|---:|
| Free | $0.005 | $0.000024783 |
| Starter / Bronze | $0.005 | $0.00002155 |
| Scale / Silver | $0.005 | $0.000016809 |
| Business / Gold | $0.005 | $0.00001293 |

At the current rates, 100 jobs cost about **$0.0075** on the Free tier and **$0.0072** on Starter, including the start fee.
One thousand jobs cost about **$0.0298** on Free and **$0.0266** on Starter.
Higher Apify plans receive additional volume discounts.

Prices are visible before every run, and `maxItems` is a hard output cap.
Start small to confirm that a query and filters fit your workflow.

### How to scrape Singapore jobs from MyCareersFuture

1. Open [MyCareersFuture Singapore Jobs Scraper](https://apify.com/automation-lab/mycareersfuture-singapore-jobs-scraper).
2. Enter a job title, skill, company, or keyword in **Search query**.
3. Set **Maximum jobs** to the number of rows you need.
4. Optionally add a recency, salary, category, employment type, or UEN filter.
5. Click **Start**.
6. Review the **Singapore job listings** dataset view.
7. Export JSON, CSV, Excel, XML, or RSS, or connect the dataset to another system.

A minimal input is:

```json
{
  "searchQuery": "software engineer",
  "sortBy": "newest",
  "maxItems": 10
}
````

A recent salary-focused search is:

```json
{
  "searchQuery": "data analyst",
  "postedWithinDays": 30,
  "salaryMin": 5000,
  "maxItems": 100,
  "maxPages": 20
}
```

An employer monitor is:

```json
{
  "companyUen": "201426535W",
  "sortBy": "newest",
  "postedWithinDays": 14,
  "maxItems": 200,
  "maxPages": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `searchQuery` | string | `software engineer` | Source-side keyword, title, skill, or employer search |
| `maxItems` | integer | `50` | Maximum matching jobs saved, from 1 to 10,000 |
| `sortBy` | string | `newest` | `newest` or source `relevance` order |
| `postedWithinDays` | integer | unset | Keep parseable posting dates within 0–365 days |
| `salaryMin` | integer | unset | Salary band maximum must reach this SGD amount |
| `salaryMax` | integer | unset | Salary band minimum must not exceed this SGD amount |
| `categories` | string\[] | `[]` | Exact category names; any requested value may match |
| `employmentTypes` | string\[] | `[]` | Exact source employment types; any may match |
| `companyUen` | string | unset | Exact case-insensitive Singapore company UEN |
| `includeDescriptionHtml` | boolean | `false` | Include original HTML alongside normalized text |
| `maxPages` | integer | `20` | Maximum 100-record API pages scanned |

Category and employment filters use the labels published in each listing.
Examples include `Information Technology`, `Engineering`, `Full Time`, `Contract`, `Internship`, and `Part Time`.

`salaryMin` and `salaryMax` test whether an advertised salary band overlaps the requested range.
When a salary filter is active, jobs without numeric salary data are excluded.

### Output example

```json
{
  "uuid": "7ae80628786621c34bf2dc83ee2dc61c",
  "jobPostId": "MCF-2026-1222459",
  "title": "Medical Social Worker - Nursing Home",
  "description": "Key Responsibilities\nIntake, Assessment and Admission Support...",
  "companyName": "THE SUPREME HR ADVISORY PTE. LTD.",
  "companyUen": "201426535W",
  "salaryMinimum": 5000,
  "salaryMaximum": 6500,
  "salaryType": "Monthly",
  "salaryCurrency": "SGD",
  "minimumYearsExperience": 2,
  "vacancies": 1,
  "status": "Open",
  "skills": ["Healthcare", "Social Work", "Case Management"],
  "categories": ["Social Services"],
  "employmentTypes": ["Full Time"],
  "positionLevels": ["Junior Executive"],
  "districts": ["Islandwide"],
  "regions": ["Islandwide"],
  "postedAt": "2026-07-16",
  "expiresAt": "2026-08-15",
  "sourceUrl": "https://www.mycareersfuture.gov.sg/job/...",
  "apiUrl": "https://api.mycareersfuture.gov.sg/v2/jobs/7ae80628786621c34bf2dc83ee2dc61c",
  "scrapedAt": "2026-07-16T06:00:00.000Z"
}
```

The exact available fields vary by employer and listing.
For example, an islandwide role may not publish a street address or coordinates.

### Filter behavior and pagination

Keyword search and newest ordering are sent to the public MyCareersFuture API.
Salary, recency, category, employment type, and UEN filters are applied to structured records returned by that API.

The Actor scans 100 source records per page until one of these conditions is met:

- `maxItems` matching jobs have been saved;
- `maxPages` has been scanned;
- the source returns an empty page;
- the source-reported result total has been reached.

Sparse client-side filters may return fewer than `maxItems` when `maxPages` is low.
Increase `maxPages` deliberately for a narrow employer or salary query.

### Tips for better job datasets

- 🎯 Use specific skills such as `Kubernetes`, `SAP`, or `registered nurse` instead of a broad word like `manager`.
- 🧪 Begin with 10–50 jobs before requesting thousands.
- 📅 Combine `sortBy: newest` and `postedWithinDays` for monitoring.
- 🏢 Use a UEN instead of a company name when you need exact employer matching.
- 💰 Remember that source salary types can be monthly, annual, daily, or hourly.
- 🧹 Use stable `uuid` values to upsert jobs between scheduled runs.
- ⏳ Compare `expiresAt` with your previous dataset to remove closed listings.
- 📄 Enable raw HTML only when downstream formatting requires it.

### Schedule a Singapore hiring monitor

Apify schedules can run this Actor hourly, daily, or weekly.
A common monitoring workflow is:

1. Run every morning with `sortBy: newest` and `postedWithinDays: 2`.
2. Store or merge rows by `uuid` in a named dataset or database.
3. Compare the new UUID set with the previous run.
4. Send alerts only for unseen jobs or changed expiry and salary fields.

For one employer, add `companyUen` and increase `maxPages` enough to scan the relevant feed.
For market-wide trends, schedule separate keyword or category tasks so each dataset has a clear purpose.

### Integrations and automation workflows

**MyCareersFuture → Google Sheets**

Append new role, employer, salary, skill, and expiry columns to a recruiting tracker after each scheduled run.

**MyCareersFuture → Slack or Discord**

Send an alert when a monitored company publishes a new engineering or sales role.

**MyCareersFuture → Make or Zapier**

Trigger CRM account activity from employer UENs and create recruiter follow-up tasks.

**MyCareersFuture → BigQuery, Snowflake, or PostgreSQL**

Upsert jobs by UUID, snapshot salary bands, and calculate category or skill trends over time.

**MyCareersFuture → webhooks**

Notify a downstream service when a run succeeds, then fetch its dataset through the Apify API.

### API usage: use the Apify API

Replace `YOUR_APIFY_TOKEN` with a token from Apify Console.

**Node.js**

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

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

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/mycareersfuture-singapore-jobs-scraper").call(run_input={
    "searchQuery": "cybersecurity analyst",
    "postedWithinDays": 30,
    "maxItems": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~mycareersfuture-singapore-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"cybersecurity analyst","postedWithinDays":30,"maxItems":100}'
```

For long runs, start the Actor asynchronously through `/runs` and poll the returned run ID.

### Use with AI agents via MCP

The Actor can be called by assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

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

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

Authenticate with your Apify account when prompted.
Then try asking:

- "Use `automation-lab/mycareersfuture-singapore-jobs-scraper` to find 50 new Singapore data engineer jobs and summarize salary bands."
- "Monitor UEN 201426535W for MyCareersFuture jobs posted in the last seven days."
- "Extract Singapore cybersecurity roles above SGD 6,000 and group their required skills."

### Reliability and source limitations

The Actor retries temporary network errors four times with exponential backoff.
Each request has a 20-second timeout, UUIDs are deduplicated, and unexpected API response shapes fail the run visibly.

MyCareersFuture controls the source data and API.
Fields, taxonomies, totals, and availability can change without notice.
The Actor does not infer hidden salaries, private application details, recruiter contact data, or unpublished employer information.

A valid search with no matching jobs may produce an empty dataset.
A complete extraction failure returns a failed run instead of silently succeeding.

### Legality: is it legal to scrape MyCareersFuture?

This Actor collects publicly accessible job-listing data without bypassing authentication.
Web scraping laws and contractual obligations vary by jurisdiction and use case.

You are responsible for:

- using the data for a lawful purpose;
- respecting MyCareersFuture terms and applicable rate limits;
- handling personal data under Singapore's PDPA and other relevant privacy laws;
- avoiding spam, discrimination, or automated decisions that violate employment law;
- retaining only the data needed for your workflow.

When in doubt, seek professional legal advice.
This documentation is not legal advice.

### Troubleshooting

**Why did the run return fewer jobs than `maxItems`?**

Strict filters may reject many source rows before the page safety cap is reached.
Check logs for scanned pages, loosen the filter, or increase `maxPages`.
Also confirm that category and employment labels exactly match source values.

**Why is a salary or address field missing?**

The employer did not publish that field for the listing.
When salary filtering is enabled, missing numeric salaries are excluded rather than guessed.

**Why did the run fail after retries?**

The public source may be temporarily unavailable or may have changed its response shape.
Review the run log, retry later, and report reproducible failures with the input and run URL.

### FAQ: frequently asked questions

**How fast is the scraper?**

It fetches up to 100 source records per HTTP request and does not launch a browser.
Small keyword runs usually complete quickly; sparse filters take longer because more pages must be scanned.

**Can I scrape every MyCareersFuture job?**

Yes, within your chosen `maxItems`, `maxPages`, run timeout, and current source availability.
For large snapshots, use no keyword, raise both limits deliberately, and schedule less frequently.

**Does it need a Singapore proxy or MyCareersFuture login?**

No.
The current implementation reads an anonymously accessible public JSON endpoint directly.

**How is this different from the official website?**

The website is designed for interactive job search.
This Actor adds bounded bulk pagination, normalized exports, strict filters, scheduling, API access, webhooks, and integrations.

**Can I monitor changed jobs, not only new jobs?**

Yes.
Store prior rows by UUID and compare `updatedAt`, salary, status, vacancies, and `expiresAt` during each scheduled run.

**Are application counts guaranteed?**

No.
The Actor returns the source's public count when present and does not estimate unavailable values.

### Related Singapore jobs scrapers

Combine this Actor with other Automation Lab tools:

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for professional-network job coverage.
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) for aggregated search results.
- [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper) for employer and job-market research.
- [Amazon Jobs Scraper](https://apify.com/automation-lab/amazon-jobs-scraper) for one major employer's openings.
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) for public ATS boards.
- [Workable Jobs Scraper](https://apify.com/automation-lab/workable-jobs-scraper) for Workable-hosted careers pages.
- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper) for Workday-hosted employers.
- [Ashby Jobs Scraper](https://apify.com/automation-lab/ashby-jobs-scraper) for Ashby-hosted job boards.

Use source-specific actors when you need stable native identifiers and fields.
Use an aggregator when broad discovery matters more than source-level detail.

# Actor input Schema

## `searchQuery` (type: `string`):

Enter a job title, skill, employer, or keyword. Leave blank to browse the newest public listings.

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

Stop after saving this many matching job listings.

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

Sort keyword results by source relevance or newest posting date.

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

Keep only jobs posted in the last N days. Jobs with an unparseable posting date are excluded when this filter is active.

## `salaryMin` (type: `integer`):

Keep jobs whose advertised salary range reaches at least this amount. Listings without a numeric salary are excluded.

## `salaryMax` (type: `integer`):

Keep jobs whose advertised salary range starts at or below this amount. Listings without a numeric salary are excluded.

## `categories` (type: `array`):

Keep jobs matching at least one exact MyCareersFuture category, such as Information Technology or Engineering.

## `employmentTypes` (type: `array`):

Keep jobs matching at least one exact source value, such as Full Time, Contract, Internship, or Part Time.

## `companyUen` (type: `string`):

Keep jobs posted by one Singapore company UEN. Matching is exact and case-insensitive.

## `includeDescriptionHtml` (type: `boolean`):

Also return the original HTML job description. Plain text is always included.

## `maxPages` (type: `integer`):

Safety cap for source pages scanned (100 jobs per page). Increase this for sparse company or salary filters.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "maxItems": 10,
  "sortBy": "newest",
  "categories": [],
  "employmentTypes": [],
  "includeDescriptionHtml": false,
  "maxPages": 5
}
```

# 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 = {
    "searchQuery": "software engineer",
    "maxItems": 10,
    "sortBy": "newest",
    "categories": [],
    "employmentTypes": [],
    "includeDescriptionHtml": false,
    "maxPages": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/mycareersfuture-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 = {
    "searchQuery": "software engineer",
    "maxItems": 10,
    "sortBy": "newest",
    "categories": [],
    "employmentTypes": [],
    "includeDescriptionHtml": False,
    "maxPages": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/mycareersfuture-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 '{
  "searchQuery": "software engineer",
  "maxItems": 10,
  "sortBy": "newest",
  "categories": [],
  "employmentTypes": [],
  "includeDescriptionHtml": false,
  "maxPages": 5
}' |
apify call automation-lab/mycareersfuture-singapore-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyCareersFuture Singapore Jobs Scraper",
        "description": "Extract public Singapore jobs with salaries, employer UENs, skills, categories, vacancies, locations, dates, and source links. Search, schedule, and export without login.",
        "version": "0.1",
        "x-build-id": "BckIO5jB1E0oHVHle"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~mycareersfuture-singapore-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-mycareersfuture-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~mycareersfuture-singapore-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-mycareersfuture-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~mycareersfuture-singapore-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-mycareersfuture-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",
                "properties": {
                    "searchQuery": {
                        "title": "🔎 Search query",
                        "type": "string",
                        "description": "Enter a job title, skill, employer, or keyword. Leave blank to browse the newest public listings.",
                        "default": "software engineer"
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many matching job listings.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Sort keyword results by source relevance or newest posting date.",
                        "default": "newest"
                    },
                    "postedWithinDays": {
                        "title": "📅 Posted within days",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Keep only jobs posted in the last N days. Jobs with an unparseable posting date are excluded when this filter is active."
                    },
                    "salaryMin": {
                        "title": "Minimum salary (SGD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Keep jobs whose advertised salary range reaches at least this amount. Listings without a numeric salary are excluded."
                    },
                    "salaryMax": {
                        "title": "Maximum salary (SGD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Keep jobs whose advertised salary range starts at or below this amount. Listings without a numeric salary are excluded."
                    },
                    "categories": {
                        "title": "Job categories",
                        "type": "array",
                        "description": "Keep jobs matching at least one exact MyCareersFuture category, such as Information Technology or Engineering.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "employmentTypes": {
                        "title": "Employment types",
                        "type": "array",
                        "description": "Keep jobs matching at least one exact source value, such as Full Time, Contract, Internship, or Part Time.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "companyUen": {
                        "title": "🏢 Company UEN",
                        "type": "string",
                        "description": "Keep jobs posted by one Singapore company UEN. Matching is exact and case-insensitive."
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Also return the original HTML job description. Plain text is always included.",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Maximum API pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap for source pages scanned (100 jobs per page). Increase this for sparse company or salary filters.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```