# Glints Job Listing (`truefetch/glints-job-listing`) Actor

Scrape Glints job listings by keyword and country with structured roles, locations, salaries, company details, and application URLs.

- **URL**: https://apify.com/truefetch/glints-job-listing.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Jobs, Social media, News
- **Stats:** 34 total users, 5 monthly users, 99.7% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

> **Affiliate disclosure:** TrueFetch may earn a commission if you sign up through an Apify link on this page, at no extra cost to you.

**Search public Glints vacancies across seven Asian markets with source-level work arrangement, recency, and employment filters, then export them through a stable 41-field Dataset.**

- **Seven Glints markets** in Southeast and East Asia are selectable in the current schema.
- **Remote, location, update-window, and job-type controls** can narrow a Glints request.
- **41 normalized fields** cover vacancies, skills, experience, salary, employers, applications, and public contacts.
- **Public Store snapshot: 22 users and a 5.0 rating from one review on July 21, 2026; its deployed description and README are from an older release.**

[**Run a one-result test**](https://apify.com/truefetch/glints-job-listing?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/glints-job-listing/api?fpr=aiagentapi)

A one-result FREE-tier test costs **$0.01500** when one job is published: $0.01000 for Actor Start plus $0.00500 for the result.

### What does Glints Job Listing do?

Glints Job Listing is a TrueFetch Apify Actor and Glints jobs API that searches public vacancies by keyword and country. Its current input contract supports Singapore, Indonesia, Malaysia, Vietnam, the Philippines, Taiwan, and Thailand. Optional controls can request a location, remote-only work arrangement, Glints update window, employment type, and salary conversion currency.

For each accepted listing, the Actor retrieves available detail data and maps it into the shared 41-field job contract. That contract includes the original Glints URL, role text, skills, experience, location, work arrangement, salary, employer information, and public company contact signals when available. Downstream systems can therefore consume one predictable shape even though individual listings remain incomplete.

Glints Job Listing is independent of Glints and is not an official Glints API. It does not authenticate as a job seeker, collect private profiles, identify applicants, or submit applications. Public search supply, detail visibility, salaries, and company data differ by country and listing.

### How do I run Glints Job Listing?

1. Open [Glints Job Listing on Apify](https://apify.com/truefetch/glints-job-listing?fpr=aiagentapi).
2. Set the required `keyword`, `country`, and `max_results` inputs.
3. Add only the optional filters your search needs; omitted filters remain non-restrictive.
4. Run one result first and inspect the source URL, match quality, and populated fields.

One scenario is used throughout this guide: find one remote, full-time Product Operations role associated with Jakarta, Indonesia, updated within the past seven days, and convert usable salary values to IDR.

```json
{
  "keyword": "Product Operations",
  "country": "Indonesia",
  "max_results": 1,
  "remote_only": true,
  "location": "Jakarta",
  "posted_since": "7 days",
  "job_type": "fulltime",
  "currency": "IDR"
}
```

`max_results` caps published jobs; it cannot create matching inventory. Combining a city with remote-only means the request asks Glints for remote roles under the resolved Jakarta location context. If that combination is too narrow, remove one optional constraint and retest.

### What data does Glints Job Listing return?

The default Dataset defines **41 fields**. Fields remain null or empty when a public Glints record does not provide sufficient evidence.

| Data group | Fields |
| --- | --- |
| Processing | `processor`, `processed_at` |
| Source and application | `platform`, `platform_url`, `official_url`, `easy_apply` |
| Role and requirements | `title`, `description`, `job_type`, `job_level`, `job_function`, `listing_type`, `skills`, `experience_range` |
| Location and arrangement | `location`, `is_remote`, `work_from_home` |
| Dates and availability | `posted_date`, `valid_through`, `applicant_count`, `vacancy_count` |
| Compensation | `salary_minimum`, `salary_maximum`, `salary_currency`, `salary_period` |
| Employer | `company_name`, `company_type`, `company_founded`, `company_industry`, `company_url`, `company_website`, `company_logo`, `company_addresses`, `company_revenue`, `company_description`, `company_rating`, `employee_count`, `review_count` |
| Public contacts | `emails`, `phones`, `social_links` |

This abbreviated object illustrates the shared Jakarta scenario; it is not a claim about a currently open vacancy:

```json
{
  "platform": "Glints",
  "platform_url": "https://glints.com/id/opportunities/jobs/product-operations/example-id",
  "official_url": null,
  "title": "Product Operations Specialist",
  "company_name": "Example Technology Indonesia",
  "location": {
    "raw": "Jakarta, Indonesia",
    "locality": "Jakarta",
    "country": "Indonesia",
    "country_code": "ID"
  },
  "is_remote": true,
  "work_from_home": "Remote",
  "job_type": "FULL_TIME",
  "salary_currency": "IDR",
  "processor": "https://apify.com/truefetch/glints-job-listing",
  "processed_at": "2026-07-21T12:00:00.000Z"
}
```

The live [Output schema](https://apify.com/truefetch/glints-job-listing/output-schema?fpr=aiagentapi) is the authoritative reference for types. In particular, null salary fields mean undisclosed or unusable source data, not zero compensation.

### What inputs can I configure?

The current local schema exposes **8 inputs**, with **3 required**.

| Input | Required | Request behavior |
| --- | :---: | --- |
| `keyword` | Yes | Role, skill, or employer phrase sent to Glints. |
| `country` | Yes | Selects one of seven Glints country markets. |
| `max_results` | Yes | Maximum published jobs, from 1 to 10,000. |
| `remote_only` | No | Requests Glints `REMOTE` work arrangements when true. |
| `location` | No | Resolves a city or region within the selected market. |
| `posted_since` | No | Converts an absolute or relative date into a Glints update window. |
| `job_type` | No | `all`, `fulltime`, `parttime`, `internship`, or `contract`. |
| `currency` | No | Converts usable numeric salaries after collection. |

Glints provides three update buckets in this implementation: up to 24 hours, up to 7 days, and up to 30 days. A requested age greater than 30 days does not add a source recency filter. `job_type: "all"` is also non-restrictive. Currency does not affect search ranking or supply. See the [Input schema](https://apify.com/truefetch/glints-job-listing/input-schema?fpr=aiagentapi) before building a form or client.

### What platforms and markets does Glints Job Listing cover?

This Actor searches **Glints only** and chooses one market per run.

| Country | Glints market code | Regional path |
| --- | --- | --- |
| Singapore | SG | `/sg/` |
| Indonesia | ID | `/id/` |
| Malaysia | MY | `/my/` |
| Vietnam | VN | `/vn/` |
| Philippines | PH | `/ph/` |
| Taiwan | TW | `/tw/` |
| Thailand | TH | `/th/` |

Location text is resolved within the selected country before its identifier is included in the search. A country name, an empty value, or a broad value such as `all` does not impose a narrower location. Location resolution can be less exact when the source returns ambiguous place matches, so test regional spelling with one result.

The schema does not claim coverage for every country where a Glints page might exist. Run separate inputs for cross-market comparison and retain the processing timestamp because public vacancy inventories move quickly.

### Why use Glints Job Listing?

| Capability | Practical value |
| --- | --- |
| Asia-focused market list | Target seven named Glints markets without maintaining country-specific request logic. |
| Native filter mapping | Send supported work arrangement, employment type, location, and update-window constraints to the search request. |
| Detail enrichment | Retrieve descriptions, skills, experience ranges, company fields, and salary components when exposed. |
| Normalized output | Compare Glints data with repeat runs or other sources through the same 41-field contract. |
| Transparent attribution | Preserve a public listing URL and source identity for verification. |
| Apify delivery | Integrate through Dataset exports, schedules, webhooks, API, or MCP. |

Its value is structured collection, not guaranteed completeness. A small, tightly filtered search may legitimately return no jobs, and the source may omit details represented by the wider schema.

### Who is Glints Job Listing for?

| Team | Useful workflow |
| --- | --- |
| Regional recruiters | Watch roles and skills by Southeast or East Asian market. |
| Workforce analysts | Compare job types, work arrangements, and disclosed salary across countries. |
| Product builders | Add Glints listings to an alert, research, or aggregation product. |
| Compensation teams | Normalize available monthly or annual salary ranges to a chosen currency. |
| Hiring-intelligence teams | Observe company vacancy activity with source and collection timestamps. |

The Actor is not designed for candidate sourcing from private profiles, outreach automation, or application submission. Review the terms and laws relevant to your storage and use of public vacancy data.

### How can I use Glints Job Listing through the API or MCP?

Use the stable Actor ID **`truefetch/glints-job-listing`**. The synchronous endpoint below runs the same Jakarta scenario and returns Dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/truefetch~glints-job-listing/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "Product Operations",
    "country": "Indonesia",
    "max_results": 1,
    "remote_only": true,
    "location": "Jakarta",
    "posted_since": "7 days",
    "job_type": "fulltime",
    "currency": "IDR"
  }'
```

An MCP client can expose only this Actor through Apify's Streamable HTTP endpoint:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=truefetch/glints-job-listing",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Ask the connected assistant to run the same one-result input. The [API page](https://apify.com/truefetch/glints-job-listing/api?fpr=aiagentapi) includes asynchronous calls, SDK clients, and OpenAPI. Store Apify tokens as secrets rather than embedding them in source control.

### How much does Glints Job Listing cost?

Billing consists of one Actor Start event and one `result` event for each normalized job written to the default Dataset.

| Apify tier | Actor Start | Per result | Per 1,000 results |
| --- | ---: | ---: | ---: |
| FREE | $0.01000 | $0.00500 | $5.00 |
| BRONZE | $0.01000 | $0.00483 | $4.83 |
| SILVER | $0.01000 | $0.00467 | $4.67 |
| GOLD / PLATINUM / DIAMOND | $0.01000 | $0.00450 | $4.50 |

One published result on FREE is **$0.01500**. Actor Start still applies when filtering yields zero items. Check the [Pricing tab](https://apify.com/truefetch/glints-job-listing/pricing?fpr=aiagentapi) before a high-volume run; the older deployed README may show obsolete pricing.

### How does Glints Job Listing compare with alternatives?

| Factor | Glints Job Listing | Multi-board Job Search | Manual Glints search |
| --- | --- | --- | --- |
| Coverage | Seven explicit Glints markets | Several compatible job boards | One browser session at a time |
| Filters | Glints-supported work, type, location, and update inputs | Varies by source | Interactive controls |
| Output | Normalized 41-field Dataset | Same broad data contract | Human-readable pages |
| Automation | Console, API, MCP, schedules, webhooks | Similar, broader scope | Manual collection |
| Best choice | Glints-specific Asian hiring signals | Cross-board discovery | Small one-off review |

Choose this Actor when Glints market coverage and source filters are central. Choose [Job Search](https://apify.com/truefetch/job-search?fpr=aiagentapi) when a single normalized request should search multiple boards. Use manual review to confirm individual listings before acting on them.

### What are the limits and troubleshooting steps?

| Observation | Explanation | Next test |
| --- | --- | --- |
| Fewer results than requested | `max_results` is a cap and filters may exhaust live supply. | Broaden the phrase or remove one optional filter. |
| Location returns nothing | The source location search may not resolve the spelling uniquely. | Try the regional name, then omit `location`. |
| A 45-day request behaves unfiltered | Glints update buckets stop at 30 days. | Use `30 days` for the broadest supported recency constraint. |
| Salary is empty | The listing may not disclose structured numeric pay. | Keep salary fields nullable and inspect the source. |
| Remote output looks unexpected | Hybrid is also recognized as a remote signal in normalized output. | Inspect `work_from_home` and the original listing text. |
| Company contacts are empty | Public enrichment is best effort and depends on a usable company website. | Do not treat null contacts as negative evidence. |
| A listing changes between runs | Vacancies can be updated, expired, or removed. | Store `processed_at` and compare snapshots. |

Reproduce problems with one simple keyword and `max_results: 1`, then share the run URL through [Apify Issues](https://apify.com/truefetch/glints-job-listing/issues?fpr=aiagentapi). Never publish an API token.

### Frequently asked questions

#### Does Glints Job Listing require a Glints login?

No Glints credentials, cookies, or account fields are public inputs. You need an Apify account to run the Actor and a token for authenticated API or MCP calls.

#### Are five or seven countries supported?

Seven are present in the current local schema: Singapore, Indonesia, Malaysia, Vietnam, the Philippines, Taiwan, and Thailand. Older Store content mentioning four countries is stale.

#### How does `posted_since` behave?

It accepts an absolute date or relative duration, converts that to age in hours, and selects the nearest supported maximum window: 24 hours, 7 days, or 30 days. Values older than 30 days add no recency filter.

#### Can remote-only and job type be combined?

Yes. They map to separate fields in the Glints search condition and can be used together with location and recency.

#### Does currency change the jobs returned?

No. It converts eligible numeric salary values after collection and does not filter or rank source listings.

#### Why do fields such as applicant count or company rating remain empty?

The shared Dataset can hold those values, but Glints does not expose every normalized attribute for every listing.

#### Can I schedule daily monitoring?

Yes. First validate a small input, then schedule it and deduplicate by source URL and collection time. A daily run with `posted_since: "24 hours"` still needs downstream handling for updated or repeated listings.

### Related TrueFetch Actors

- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing?fpr=aiagentapi) — choose it for Indeed-specific market coverage and its supported request filters.
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi) — choose it for LinkedIn role, applicant, and company signals.
- [Job Search](https://apify.com/truefetch/job-search?fpr=aiagentapi) — choose it to search several compatible boards through one normalized contract.

### Support and last updated

- [Run Glints Job Listing](https://apify.com/truefetch/glints-job-listing?fpr=aiagentapi)
- [View API options](https://apify.com/truefetch/glints-job-listing/api?fpr=aiagentapi)
- [Report an issue](https://apify.com/truefetch/glints-job-listing/issues?fpr=aiagentapi)
- [Join the TrueFetch Telegram group](https://t.me/TrueFetch)
- [Contact support on Telegram](https://t.me/AiAgentApi)

**Last updated:** July 21, 2026. Current local schema, metadata, pricing, and read-only runtime behavior were verified separately from obsolete deployed Store copy; public statistics above are a dated snapshot.

Start with the Jakarta one-result scenario, confirm the filter combination and fields your workflow needs, and scale only after that check.

[**Run a one-result test**](https://apify.com/truefetch/glints-job-listing?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/glints-job-listing/api?fpr=aiagentapi)

# Actor input Schema

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

Job title, skill, or company name to search for

## `country` (type: `string`):

Country where the target job listings are located

## `max_results` (type: `integer`):

Maximum number of jobs to return

## `remote_only` (type: `boolean`):

Restrict results to remote positions only

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

City or region to focus the job search results on

## `posted_since` (type: `string`):

Use Glints update windows up to 30 days

## `job_type` (type: `string`):

Employment type to filter by: full-time, contract, etc.

## `currency` (type: `string`):

Target currency for converting salary figures

## Actor input object example

```json
{
  "keyword": "Marketing",
  "country": "Singapore",
  "max_results": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset overview of normalized job listings and company fields collected by All Jobs Scraper.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "Marketing",
    "country": "Singapore",
    "max_results": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/glints-job-listing").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keyword": "Marketing",
    "country": "Singapore",
    "max_results": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/glints-job-listing").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "Marketing",
  "country": "Singapore",
  "max_results": 10
}' |
apify call truefetch/glints-job-listing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/glints-job-listing",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GZzfqvUxW6g0C5c1G/builds/umhguZ5EkWDR28aKt/openapi.json