# Thailand IT Products & Price Scraper — JIB, Advice, iHAVECPU (`mai_amm/thailand-it-products-price-scraper`) Actor

Search JIB, Advice and iHAVECPU for THB product prices, availability, images and optional specifications. $5 per 1,000 fresh products; one-time free-account trial.

- **URL**: https://apify.com/mai_amm/thailand-it-products-price-scraper.md
- **Developed by:** [wiseld_squid](https://apify.com/mai_amm) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 returned fresh products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Thailand IT Products & Price Scraper

Search **JIB, Advice and iHAVECPU** in one run. Collect Thai IT product prices, availability, images and optional specifications in a consistent dataset for price research, reporting and AI agents.

Supported searches include CPUs, graphics cards, RAM, SSDs, notebooks, monitors, keyboards, mice, accessories and other products listed by the selected stores.

### Quick start

1. Enter a keyword or model, such as `RTX 5070`, `Ryzen`, `DDR5` or `เมาส์`.
2. Choose all three stores or one store.
3. Set the maximum matching products per store.
4. Optionally enable product details for specifications and additional pictures.
5. Run and export the dataset as JSON, CSV, Excel or another Apify-supported format.

```json
{
  "keyword": "RTX 5070",
  "store": "all",
  "maxItemsPerStore": 50,
  "includeDetails": false,
  "matchTitlesOnly": true,
  "maxPagesPerStore": 10
}
```

To collect richer product records from one retailer:

```json
{
  "keyword": "เมาส์",
  "store": "advice",
  "maxItemsPerStore": 20,
  "includeDetails": true
}
```

### What you receive

Each product contains its retailer, product ID, name, product link, THB price, availability and observation time. Brand, SKU, reference price and pictures are included when provided. Enabling details adds available specifications, additional pictures and descriptions.

The dataset identifies products by **retailer + product ID**. Similar products from different stores remain separate offers. Matching names do not prove that specifications, bundles, warranties or conditions are identical.

Example fields:

```json
{
  "retailer": "Advice",
  "productId": "A0167640",
  "name": "VGA ZOTAC GEFORCE RTX 5070 GAMING SOLID OC - 12GB GDDR7",
  "price": 30400,
  "originalPrice": 30500,
  "currency": "THB",
  "brand": "ZOTAC",
  "availability": "in_stock",
  "detailFetched": true,
  "specificationsStatus": "available",
  "reusedResult": false
}
```

Prices in the example are illustrative observations, not current purchase offers. Open the product link to confirm price and conditions.

Missing prices are `null`, never zero. A store can retain an older detail-page price for an unavailable product; `detailPrice` is kept separate from an unavailable listing price. Availability can be `unknown`. Empty source specification tables are reported as `not_provided_by_source`, and `detailFetched` shows whether details were collected.

### Search controls

| Input | Purpose |
| --- | --- |
| `keyword` | One Thai or English keyword/model per run. |
| `store` | `all`, `jib`, `advice` or `ihavecpu`. |
| `maxItemsPerStore` | Maximum matching products per store. Paying accounts can use `0` for all matches reachable within the run's limits. |
| `includeDetails` | Add available specifications and more images. Longer runs and higher platform usage are possible. |
| `matchTitlesOnly` | Require query words in product names, including common Thai/English category equivalents. Disable to retain the retailer's broader matches from descriptions or specifications. |
| `maxPagesPerStore` | Search depth. Increase when matches are sparse. |
| `maxRequests`, `maxDownloadMB`, `requestTimeoutSecs` | Work limits to control run duration and usage. |

The item limit applies **after matching**, so the Actor continues through additional pages when early results are filtered out. Searches can include complete PCs, accessories and related models; use specific keywords and compare the actual specifications. This Actor does not promise exact model matching or a complete retailer catalog.

The run summary reports products returned, store failures, limits reached and whether listing pagination ended. Reaching an item, page, budget or time limit can leave further products uncollected. If one store fails, results from stores that completed remain available. Details may be incomplete when work limits are reached.

### Pricing

**$0.005 per returned fresh product — $5 per 1,000 products.** No startup service fee. The same product price applies with or without optional details. A run returning 100 charged products has a $0.50 Actor service fee.

Only emitted fresh products for paying accounts incur the product service fee. Filtered-out products, empty results and cached trial results have no product service fee. Apify platform usage is charged separately to the account running the Actor, as shown in Apify's run costs. Set the maximum charge in Apify to control service spending.

### Free-account trial and paid use

- **Free Apify accounts:** one live trial attempt per account, with up to **10 products total across selected stores**. Later runs return the saved first result, even if the keyword, store, item limit or Actor version changes. The timestamps remain those of the original trial; `reusedResult: true` identifies a replay.
- **Paying Apify accounts:** fresh collection on each run, with no free-trial item cap. Set `maxItemsPerStore: 0` to remove the item limit, subject to selected page/work limits, available products and your charge budget.

Your Apify account status determines access automatically. There is no customer-controlled paid-mode switch. Platform usage can still apply to a free trial. An interrupted or failed live trial attempt consumes that attempt; a concurrently running trial must finish before its saved results can be replayed. Saved results depend on retained Apify storage.

### Repeated monitoring and API use

Save your input as an Apify Task and schedule it to take fresh snapshots on a paying account. Each fresh run is billed for its returned products. Retain datasets to compare observations over time; this Actor does not maintain price history or emit automatic price-change alerts.

Use the **API** tab for generated examples. A Python example:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("mai_amm/thailand-it-products-price-scraper").call(
    run_input={"keyword": "DDR5", "store": "all", "maxItemsPerStore": 20}
)
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["retailer"], product["name"], product["price"])
```

This Actor collects a snapshot of public product information. It does not place orders, log into shopping accounts or guarantee future prices or store availability.

# Actor input Schema

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

Thai or English, for example RTX 5070, DDR5, notebook or เมาส์. One search phrase per run.

## `store` (type: `string`):

Compare all stores or search one retailer.

## `maxItemsPerStore` (type: `integer`):

Limit applies after matching. Paying accounts: 0 means all reachable within page/work/charge limits. Free trial: 10 products total, once.

## `includeDetails` (type: `boolean`):

Collect available product details. Longer runs may incur more platform usage. Empty source specifications remain empty.

## `matchTitlesOnly` (type: `boolean`):

Includes common Thai/English category equivalents. Disable to keep broader retailer matches from descriptions/specifications.

## `maxPagesPerStore` (type: `integer`):

Increase to search deeper. An item limit of 0 still respects this work limit.

## `maxRequests` (type: `integer`):

Run-wide work limit, including retries and product details.

## `maxDownloadMB` (type: `integer`):

Stop starting further reads after reaching this run-wide budget. A final response may cross the budget.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each store read. The run timeout is controlled separately in Apify.

## Actor input object example

```json
{
  "keyword": "RTX 5070",
  "store": "all",
  "maxItemsPerStore": 50,
  "includeDetails": false,
  "matchTitlesOnly": true,
  "maxPagesPerStore": 10,
  "maxRequests": 300,
  "maxDownloadMB": 100,
  "requestTimeoutSecs": 25
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `summary` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mai_amm/thailand-it-products-price-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mai_amm/thailand-it-products-price-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call mai_amm/thailand-it-products-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mai_amm/thailand-it-products-price-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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