Pricing

from $1.00 / 1,000 results

Try for free

Go to Apify Store

OpenRice Scraper — Hong Kong Restaurant Data

Try for free

Scrape OpenRice Hong Kong: ~28,800 open restaurants with review scores, HKD price bands, opening hours, cuisines, bilingual addresses, phones and GPS. Business listings only.

Pricing

from $1.00 / 1,000 results

Rating

0.0

(0)

Developer

Feeds HK Data

Actor stats

Bookmarked

Total users

Monthly active users

a day ago

Last modified

main.py

1"""Apify actor entrypoint — Hong Kong restaurants scraper (OpenRice)."""
2import asyncio
3
4from apify import Actor
5
6from core.hk_restaurants import SourceUnavailable, scrape_restaurants, total_count
7
8# One dataset API call per page of results instead of one per row: a
9# whole-city run makes ~580 calls instead of ~29,000.
10PUSH_BATCH = 50
11
12# Apify bills this event automatically for every dataset row. The SDK only
13# enforces the buyer's "maximum cost per run" when `push_data` is given an
14# event name, which the automatic event never is, so the Actor must stop at
15# the budget itself. Rows past it are delivered but never paid for.
16ITEM_EVENT = "apify-default-dataset-item"
17
18
19def affordable_rows(requested: int) -> int:
20    """Cap the run at the number of rows the buyer's budget pays for."""
21    cap = Actor.get_charging_manager().calculate_max_event_charge_count_within_limit(ITEM_EVENT)
22    if cap is not None and cap < requested:
23        Actor.log.warning(
24            f"The maximum cost per run pays for {max(cap, 0)} restaurants; "
25            f"stopping there instead of {requested}."
26        )
27        return max(cap, 0)
28    return requested
29
30
31async def fail_blocked(pushed: int, exc: Exception) -> None:
32    """End the run as failed once the source keeps refusing.
33
34    Failing rather than succeeding with fewer rows is deliberate: a scheduled
35    pipeline must not mistake a partial dataset for the whole city.
36    """
37    Actor.log.error(f"Source stopped answering: {exc}")
38    if pushed:
39        message = (
40            f"OpenRice stopped answering (bot protection or an outage) after {pushed} restaurants. "
41            f"Those {pushed} are in the dataset; run again later for the rest."
42        )
43    else:
44        message = "OpenRice is not answering right now (bot protection or an outage). Run again later."
45    await Actor.fail(status_message=message)
46
47
48async def main() -> None:
49    async with Actor:
50        payload = await Actor.get_input() or {}
51        keywords = (payload.get("keywords") or "").strip() or None
52        district_id = str(payload.get("districtId") or "").strip() or None
53        cuisine_id = str(payload.get("cuisineId") or "").strip() or None
54        include_inactive = bool(payload.get("includeInactive", False))
55        requested = int(payload.get("maxItems") or 200)
56        max_items = affordable_rows(requested)
57        delay = float(payload.get("requestDelaySeconds") or 1)
58        if max_items == 0:
59            await Actor.set_status_message(
60                "Maximum cost per run is too low for a single restaurant.", is_terminal=True
61            )
62            return
63
64        try:
65            available = total_count(
66                keywords=keywords,
67                district_id=district_id,
68                cuisine_id=cuisine_id,
69                include_inactive=include_inactive,
70            )
71            Actor.log.info(f"Matching restaurants on source: {available}")
72        except SourceUnavailable as exc:
73            await fail_blocked(0, exc)
74            return
75        except Exception as exc:  # noqa: BLE001 — informational only
76            Actor.log.warning(f"Could not read total count: {exc}")
77
78        pushed = 0
79        batch: list[dict] = []
80        blocked: SourceUnavailable | None = None
81        try:
82            for restaurant in scrape_restaurants(
83                keywords=keywords,
84                district_id=district_id,
85                cuisine_id=cuisine_id,
86                max_items=max_items,
87                delay=delay,
88                include_inactive=include_inactive,
89            ):
90                batch.append(restaurant.to_dict())
91                if len(batch) >= PUSH_BATCH:
92                    await Actor.push_data(batch)
93                    pushed += len(batch)
94                    batch = []
95                    if pushed % 500 == 0:
96                        Actor.log.info(f"Pushed {pushed} restaurants…")
97        except SourceUnavailable as exc:
98            blocked = exc
99
100        if batch:  # fetched before any cut-off: deliver them, never drop them
101            await Actor.push_data(batch)
102            pushed += len(batch)
103        if blocked is not None:
104            await fail_blocked(pushed, blocked)
105            return
106
107        Actor.log.info(f"Done. {pushed} restaurants pushed to the dataset.")
108        if max_items < requested and pushed >= max_items:
109            # Shown on the run page: a short dataset must not look like a bug.
110            await Actor.set_status_message(
111                f"Stopped at {pushed} restaurants: the run's maximum cost pays for no more. "
112                "Raise 'Maximum cost per run' to get the rest.",
113                is_terminal=True,
114            )
115
116
117if __name__ == "__main__":
118    asyncio.run(main())

requirements.txt

1apify ~= 2.6
2pydantic < 2.12
3browserforge == 1.2.3

Dockerfile

FROM apify/actor-python:3.12

COPY requirements.txt ./

RUN echo "Python version:" \
 && python --version \
 && echo "Installing dependencies:" \
 && pip install -r requirements.txt \
 && echo "All installed Python packages:" \
 && pip freeze

COPY . ./

CMD ["python3", "-m", "main"]

core/init.py

core/hk_restaurants.py

1"""OpenRice Hong Kong restaurant scraper — the second data source.
2
3Same shape as `hk_jobs.py`: a polite, dependency-light client over a public
4JSON endpoint, returning dataclasses that serialise straight to a dataset.
5
6Every behaviour below was verified against the live API. Each one breaks a
7naive scraper while still returning HTTP 200 or a plausible-looking dataset.
8
91. A browser-like ``User-Agent`` is mandatory. Requests without one get a
10   blanket 403 — the endpoint itself is open, the UA filter is the only gate.
112. The ``page`` parameter is silently ignored: every value returns the same
12   first rows. Real pagination is ``startAt`` (a row offset).
133. ``startAt + rows`` may not exceed 10,000; past that the API answers
14   HTTP 500. The city has ~29,000 open venues, so a query larger than the cap
15   is split into one query per district (the biggest district holds < 2,000).
164. Search results include moved and renovating venues (~13%). A moved venue
17   is listed again at its new address, so they are excluded by default. The
18   ``status`` filter runs on a search index that lags the records: about 2 in
19   10,000 rows still come back moved, renovating or unlabelled, so each row's
20   own status is checked again before it is kept.
215. ``reviewCount`` is the real review total. Smile + cry leaves out the
22   neutral ("OK") reviews and undercounts every venue.
236. The ``/r{poiId}`` restaurant URL is a 404, and HTML pages sit behind a bot
24   challenge that trips within a dozen requests. Only the JSON API is called;
25   links use the API's own ``shortenUrl``.
267. The JSON API has the same protection, only far more tolerant: after a
27   whole-city run on top of a day of probing, one IP was served a BytePlus
28   challenge page (HTTP 200, HTML) for 12-16 minutes, then JSON again. Retries
29   back off for over 20 minutes to outlast such a block, then raise
30   ``SourceUnavailable`` so the caller can stop cleanly with what it has.
31"""
32from __future__ import annotations
33
34import gzip
35import http.client
36import json
37import logging
38import time
39import urllib.parse
40import urllib.request
41from dataclasses import asdict, dataclass, field
42from datetime import datetime, timezone
43from typing import Iterator
44
45log = logging.getLogger(__name__)
46
47API = "https://www.openrice.com/api/v2/search"
48UA = (
49    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
50    "(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
51)
52PAGE_ROWS = 200         # honoured by the server; ~25% faster per row than 50
53DEEP_LIMIT = 10_000     # startAt + rows beyond this returns HTTP 500
54# Seconds to wait before each retry. The short steps absorb network blips; the
55# long tail (22.5 min in total) outlasts the 12-16 minute bot-protection block
56# seen live, instead of throwing away a 40-minute whole-city run.
57RETRY_WAITS = (2, 4, 8, 16, 60, 120, 240, 300, 300, 300)
58MAX_RETRIES = len(RETRY_WAITS) + 1
59
60STATUS_OPEN = 10
61STATUS_LABELS = {10: "open", 4: "moved", 3: "under_renovation"}
62
63# `dayOfWeek` follows java.util.Calendar: 1 is Sunday. Verified against a
64# venue whose page reads "Mon - Sat 12:00 - 23:00, Sun Closed".
65WEEKDAYS = {2: "mon", 3: "tue", 4: "wed", 5: "thu", 6: "fri", 7: "sat", 1: "sun"}
66HOURS_ORDER = [*WEEKDAYS.values(), "public_holiday", "public_holiday_eve"]
67
68# OpenRice exposes price as an opaque id. Bands as shown on the HK site.
69PRICE_BANDS = {
70    1: ("Below $50", 0, 50),
71    2: ("$51-100", 51, 100),
72    3: ("$101-200", 101, 200),
73    4: ("$201-400", 201, 400),
74    5: ("$401-800", 401, 800),
75    6: ("Above $801", 801, None),
76}
77
78
79@dataclass
80class Restaurant:
81    poi_id: int
82    name: str
83    name_other_lang: str
84    address: str
85    address_other_lang: str
86    district: str | None
87    district_id: int | None
88    latitude: float | None
89    longitude: float | None
90    price_band: str | None
91    price_min_hkd: int | None
92    price_max_hkd: int | None
93    score_overall: float | None
94    smiles: int | None
95    cries: int | None
96    review_count: int | None
97    bookmark_count: int | None
98    cuisines: list[str] = field(default_factory=list)
99    dish_types: list[str] = field(default_factory=list)
100    phones: list[str] = field(default_factory=list)
101    opening_hours: dict[str, list[str]] | None = None
102    open_since: str | None = None
103    status: str | None = None
104    moved_to_poi_id: int | None = None
105    url: str | None = None
106    scraped_at: str = ""
107
108    def to_dict(self) -> dict:
109        return asdict(self)
110
111
112class RateLimiter:
113    """Polite fixed-delay limiter — one request per `delay` seconds."""
114
115    def __init__(self, delay: float = 1.0):
116        self.delay = delay
117        self._last = 0.0
118
119    def wait(self) -> None:
120        gap = time.monotonic() - self._last
121        if gap < self.delay:
122            time.sleep(self.delay - gap)
123        self._last = time.monotonic()
124
125
126class SourceUnavailable(RuntimeError):
127    """OpenRice kept refusing after every retry: bot protection or an outage."""
128
129
130def _request(params: dict, limiter: RateLimiter | None = None) -> dict:
131    """GET the search endpoint with retry/backoff, returning parsed JSON."""
132    url = f"{API}?{urllib.parse.urlencode(params)}"
133    headers = {
134        "User-Agent": UA,                       # mandatory — see module docstring
135        "Accept": "application/json, text/plain, */*",
136        "Accept-Encoding": "gzip",              # 8.5x less transfer: ~29 KB -> ~3.4 KB per row
137        "Accept-Language": "en-HK,en;q=0.9",
138        "Referer": "https://www.openrice.com/en/hongkong",
139    }
140    last_err: Exception | None = None
141    for attempt in range(MAX_RETRIES):
142        if limiter:
143            limiter.wait()
144        try:
145            req = urllib.request.Request(url, headers=headers)
146            with urllib.request.urlopen(req, timeout=60) as resp:
147                raw = resp.read()
148                if resp.headers.get("Content-Encoding") == "gzip":
149                    raw = gzip.decompress(raw)
150                return json.loads(raw)
151        # OSError covers HTTP/URL errors, timeouts and dropped connections;
152        # ValueError is a non-JSON body such as a bot-challenge page.
153        except (OSError, ValueError, http.client.HTTPException) as exc:
154            last_err = exc
155            if attempt < len(RETRY_WAITS):
156                wait = RETRY_WAITS[attempt]
157                if wait >= 60:
158                    # Visible in the run log, or a run sitting out a block looks hung.
159                    reason = "non-JSON answer" if isinstance(exc, ValueError) else f"{type(exc).__name__}: {exc}"
160                    log.warning(
161                        f"OpenRice request failed ({reason}), possibly bot protection. "
162                        f"Waiting {wait}s before attempt {attempt + 2} of {MAX_RETRIES}."
163                    )
164                time.sleep(wait)
165    raise SourceUnavailable(f"OpenRice request failed after {MAX_RETRIES} attempts: {last_err}")
166
167
168def _categories(raw: dict, type_id: int) -> list[str]:
169    """Category names of one type — 1 is cuisine, 3 is dish/venue type."""
170    return [
171        c.get("name")
172        for c in (raw.get("categories") or [])
173        if c.get("categoryTypeId") == type_id and c.get("name")
174    ]
175
176
177def _opening_hours(raw: dict) -> dict[str, list[str]] | None:
178    """Weekly hours as ``{"mon": ["11:30-15:00", "18:00-22:30"], ...}``.
179
180    ``[]`` means closed that day. ``isClose`` must win over the period fields:
181    closed days still carry the regular hours in ``period1Start/End``, so
182    reading the periods first reports a closed Sunday as open. Date-specific
183    exceptions (``day``/``lunarDay``/``weekOfMonth``) are not a weekly pattern
184    and are skipped. Days the source does not state are left out, never
185    guessed.
186    """
187    found: dict[str, list[str]] = {}
188    for h in raw.get("poiHours") or []:
189        if h.get("day") or h.get("lunarDay") or h.get("weekOfMonth"):
190            continue
191        dow = h.get("dayOfWeek")
192        if dow in WEEKDAYS:
193            key = WEEKDAYS[dow]
194        elif dow == 0 and h.get("isHoliday"):
195            key = "public_holiday"
196        elif dow == 0 and h.get("isHolidayEve"):
197            key = "public_holiday_eve"
198        else:
199            continue
200        if key in found:
201            continue
202        if h.get("isClose"):
203            found[key] = []
204        elif h.get("is24hr"):
205            found[key] = ["00:00-24:00"]
206        else:
207            spans = []
208            n = 1
209            while f"period{n}Start" in h or f"period{n}End" in h:
210                start, end = h.get(f"period{n}Start"), h.get(f"period{n}End")
211                if start and end:
212                    spans.append(f"{start[:5]}-{end[:5]}")
213                n += 1
214            if spans:
215                found[key] = spans
216    return {k: found[k] for k in HOURS_ORDER if k in found} or None
217
218
219def _parse(raw: dict, now: str) -> Restaurant:
220    district = raw.get("district") or {}
221    price_id = raw.get("priceRangeId")
222    band = PRICE_BANDS.get(price_id) if isinstance(price_id, int) else None
223    status_code = raw.get("status")
224    moved_to = raw.get("moveToId")
225
226    def _float(key: str) -> float | None:
227        try:
228            return float(raw[key])
229        except (KeyError, TypeError, ValueError):
230            return None
231
232    def _int(key: str) -> int | None:
233        try:
234            return int(raw[key])
235        except (KeyError, TypeError, ValueError):
236            return None
237
238    poi_id = raw.get("poiId")
239    score = _float("scoreOverall")
240    return Restaurant(
241        poi_id=int(poi_id) if poi_id is not None else 0,
242        name=raw.get("name") or "",
243        name_other_lang=raw.get("nameOtherLang") or "",
244        address=raw.get("address") or "",
245        address_other_lang=raw.get("addressOtherLang") or "",
246        district=district.get("name"),
247        district_id=district.get("districtId"),
248        latitude=_float("mapLatitude"),
249        longitude=_float("mapLongitude"),
250        price_band=band[0] if band else None,
251        price_min_hkd=band[1] if band else None,
252        price_max_hkd=band[2] if band else None,
253        # 0 means "too few reviews to score yet", not a score of zero.
254        score_overall=round(score, 2) if score else None,
255        smiles=_int("scoreSmile"),
256        cries=_int("scoreCry"),
257        review_count=_int("reviewCount"),
258        bookmark_count=_int("bookmarkedUserCount"),
259        cuisines=_categories(raw, 1),
260        dish_types=_categories(raw, 3),
261        phones=[p for p in (raw.get("phones") or []) if p],
262        opening_hours=_opening_hours(raw),
263        open_since=raw.get("openSince") or None,
264        status=STATUS_LABELS.get(status_code) if isinstance(status_code, int) else None,
265        moved_to_poi_id=moved_to if isinstance(moved_to, int) and moved_to > 0 else None,
266        url=raw.get("shortenUrl")
267        or (f"https://www.openrice.com/en/hongkong/r-restaurant-r{poi_id}" if poi_id else None),
268        scraped_at=now,
269    )
270
271
272def _params(
273    keywords: str | None,
274    district_id: str | None,
275    cuisine_id: str | None,
276    include_inactive: bool,
277) -> dict:
278    """Base query parameters shared by counting and paging."""
279    params: dict = {"uiLang": "en", "uiCity": "hongkong"}
280    if keywords:
281        params["whatwhere"] = keywords
282    if district_id:
283        params["districtId"] = district_id
284    if cuisine_id:
285        params["cuisineId"] = cuisine_id
286    if not include_inactive:
287        params["status"] = STATUS_OPEN
288    return params
289
290
291def _probe(base: dict, limiter: RateLimiter | None = None) -> tuple[int, list[dict]]:
292    """Match count plus the per-district breakdown — one cheap request.
293
294    The ``districts`` facet in a response is already narrowed by the query's
295    own filters, so its counts describe exactly the rows a split would fetch.
296    """
297    data = _request({**base, "rows": 1, "startAt": 0}, limiter)
298    count = int((data.get("paginationResult") or {}).get("count") or 0)
299    facets = (data.get("refineSearchFilter") or {}).get("districts") or []
300    return count, facets
301
302
303def _leaf_districts(facets: list[dict], exclude: str | None = None) -> list[str]:
304    """District ids that partition a query without overlap.
305
306    Ids ending in 999 are whole regions and negative ids are named sub-areas
307    (Soho, Lan Kwai Fong, ...) that overlap the real districts; neither may be
308    used as a partition or venues would be fetched twice.
309    """
310    out = []
311    for facet in facets:
312        fid = facet.get("id")
313        if not isinstance(fid, int) or fid <= 0 or fid % 1000 == 999:
314            continue
315        if not facet.get("count") or str(fid) == str(exclude):
316            continue
317        out.append(str(fid))
318    return out
319
320
321def _paginate(
322    base: dict,
323    limiter: RateLimiter,
324    seen: set[int],
325    max_items: int,
326    now: str,
327) -> Iterator[Restaurant]:
328    """Walk one query by `startAt` offset, never past the 10,000-row cap.
329
330    Stops when the API runs out of rows or stops producing anything new, so a
331    silently capped result set ends the walk instead of spinning forever.
332    """
333    want_status = base.get("status")
334    dropped: set[int] = set()  # stale rows skipped here; never counted towards max_items
335    start_at = 0
336    while len(seen) < max_items and start_at < DEEP_LIMIT:
337        # Never ask for more than the run still needs: a 37-row run fetches 37.
338        rows_wanted = min(PAGE_ROWS, DEEP_LIMIT - start_at, max_items - len(seen))
339        data = _request({**base, "rows": rows_wanted, "startAt": start_at}, limiter)
340        rows = (data.get("paginationResult") or {}).get("results") or []
341        if not rows:
342            return
343
344        fresh = 0
345        for raw in rows:
346            poi_id = raw.get("poiId")
347            if poi_id is None or poi_id in seen or poi_id in dropped:
348                continue
349            fresh += 1  # new to this walk, even if dropped below: the API is not repeating
350            if want_status is not None and raw.get("status") != want_status:
351                dropped.add(poi_id)  # stale index entry: the record itself is no longer open
352                continue
353            seen.add(poi_id)
354            yield _parse(raw, now)
355            if len(seen) >= max_items:
356                return
357
358        if fresh == 0:          # API repeating itself — deep-page limit reached
359            return
360        # Advance by what actually came back: if the server ever returns fewer
361        # rows than asked, advancing by the request size would skip rows.
362        start_at += len(rows)
363
364
365def total_count(
366    keywords: str | None = None,
367    district_id: str | None = None,
368    cuisine_id: str | None = None,
369    include_inactive: bool = False,
370) -> int:
371    """How many restaurants match — one cheap request."""
372    count, _ = _probe(_params(keywords, district_id, cuisine_id, include_inactive))
373    return count
374
375
376def scrape_restaurants(
377    keywords: str | None = None,
378    district_id: str | None = None,
379    cuisine_id: str | None = None,
380    max_items: int = 200,
381    delay: float = 1.0,
382    include_inactive: bool = False,
383) -> Iterator[Restaurant]:
384    """Yield restaurants, de-duplicated by poi_id, until `max_items`.
385
386    Up to 10,000 results come from one query in the source's own order
387    (best-rated first). Beyond that the query is split into one query per
388    district, which reaches every venue that has a district (~99.6%).
389    """
390    limiter = RateLimiter(delay)
391    now = datetime.now(timezone.utc).isoformat(timespec="seconds")
392    seen: set[int] = set()
393    base = _params(keywords, district_id, cuisine_id, include_inactive)
394
395    if max_items <= DEEP_LIMIT:
396        yield from _paginate(base, limiter, seen, max_items, now)
397        return
398
399    count, facets = _probe(base, limiter)
400    leaves = _leaf_districts(facets, exclude=district_id)
401    if count <= DEEP_LIMIT or not leaves:
402        # No split needed, or the district facet vanished from the response:
403        # fall back to the capped single walk rather than returning nothing.
404        yield from _paginate(base, limiter, seen, max_items, now)
405        return
406
407    for did in leaves:
408        if len(seen) >= max_items:
409            return
410        yield from _paginate({**base, "districtId": did}, limiter, seen, max_items, now)

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "hong-kong-restaurants-scraper",
    "title": "OpenRice Scraper — Hong Kong Restaurant Data",
    "description": "Scrape OpenRice Hong Kong: ~28,800 open restaurants with review scores, HKD price bands, opening hours, cuisines, bilingual addresses, phones and GPS. Business listings only.",
    "version": "0.1",
    "buildTag": "latest",
    "meta": {
        "templateId": "python-start"
    },
    "input": "./input_schema.json",
    "output": "./output_schema.json",
    "dockerfile": "../Dockerfile",
    "readme": "../README.md",
    "storages": {
        "dataset": "./dataset_schema.json"
    }
}

.actor/input_schema.json

{
    "title": "Hong Kong Restaurants Scraper input",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "keywords": {
            "title": "Search keywords",
            "type": "string",
            "description": "Free-text search, e.g. 'dim sum', 'ramen', a restaurant name or a street. Leave empty to scrape everything.",
            "editor": "textfield",
            "example": "dim sum",
            "prefill": "dim sum"
        },
        "districtId": {
            "title": "District ID",
            "type": "string",
            "description": "Optional district filter (open venues in brackets). Regions: 1999 = Hong Kong Island (7,633), 2999 = Kowloon (10,857), 3999 = New Territories (9,397), 4999 = Outlying Islands (917). Districts: 2008 = Tsim Sha Tsui (1,791), 1003 = Central (1,343), 3003 = Yuen Long (1,292), 3018 = Tsuen Wan (1,272), 3005 = Tuen Mun (1,254), 2026 = Kwun Tong (1,138), 2010 = Mong Kok (1,135), 1022 = Wan Chai (1,071), 1019 = Causeway Bay (1,056), 3007 = Sha Tin (821), 3020 = Tseung Kwan O (770), 2019 = Sham Shui Po (761). Neighbourhoods (overlap the districts): -9006 = Soho, -9007 = Lan Kwai Fong, -35242 = Kennedy Town, -35244 = Sai Ying Pun. The README lists all 85 districts.",
            "editor": "textfield",
            "example": "2008"
        },
        "cuisineId": {
            "title": "Cuisine ID",
            "type": "string",
            "description": "Optional cuisine filter (open venues in brackets). 1004 = Hong Kong Style (10,671), 4000 = Western (4,445), 1002 = Guangdong (3,438), 2009 = Japanese (3,252), 6000 = International (1,780), 1009 = Taiwan (1,216), 2004 = Thai (802), 1008 = Sichuan (738), 3006 = Italian (688), 4001 = American (657), 2001 = Korean (503), 1001 = Chiu Chow (481), 2002 = Vietnamese (328).",
            "editor": "textfield",
            "example": "2009"
        },
        "maxItems": {
            "title": "Maximum restaurants",
            "type": "integer",
            "description": "Hard cap on how many restaurants to return. The whole city is about 28,900 open venues and takes about 40 minutes; above 10,000 the Actor splits the search by district to get past the source's paging limit. The run also stops at the number of restaurants your Maximum cost per run pays for.",
            "default": 200,
            "prefill": 100,
            "minimum": 1,
            "maximum": 40000
        },
        "includeInactive": {
            "title": "Include moved and renovating venues",
            "type": "boolean",
            "description": "Off by default: only currently open venues are returned. Turn on to also get venues marked moved (listed again at their new address, see moved_to_poi_id) or under renovation, e.g. to study churn.",
            "default": false,
            "editor": "checkbox"
        },
        "requestDelaySeconds": {
            "title": "Delay between requests (seconds)",
            "type": "integer",
            "description": "Politeness delay. Keep at 1 or higher to stay well-behaved.",
            "default": 1,
            "prefill": 1,
            "minimum": 1,
            "maximum": 10
        }
    },
    "required": []
}

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "fields": {
        "type": "object",
        "properties": {
            "poi_id": {
                "type": "integer"
            },
            "name": {
                "type": "string"
            },
            "name_other_lang": {
                "type": "string"
            },
            "address": {
                "type": "string"
            },
            "address_other_lang": {
                "type": "string"
            },
            "district": {
                "type": [
                    "string",
                    "null"
                ]
            },
            "district_id": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "latitude": {
                "type": [
                    "number",
                    "null"
                ]
            },
            "longitude": {
                "type": [
                    "number",
                    "null"
                ]
            },
            "price_band": {
                "type": [
                    "string",
                    "null"
                ]
            },
            "price_min_hkd": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "price_max_hkd": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "score_overall": {
                "type": [
                    "number",
                    "null"
                ]
            },
            "smiles": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "cries": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "review_count": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "bookmark_count": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "cuisines": {
                "type": "array"
            },
            "dish_types": {
                "type": "array"
            },
            "phones": {
                "type": "array"
            },
            "opening_hours": {
                "type": [
                    "object",
                    "null"
                ]
            },
            "open_since": {
                "type": [
                    "string",
                    "null"
                ]
            },
            "status": {
                "type": [
                    "string",
                    "null"
                ]
            },
            "moved_to_poi_id": {
                "type": [
                    "integer",
                    "null"
                ]
            },
            "url": {
                "type": [
                    "string",
                    "null"
                ]
            },
            "scraped_at": {
                "type": "string"
            }
        }
    },
    "views": {
        "overview": {
            "title": "Overview",
            "transformation": {
                "fields": [
                    "name",
                    "district",
                    "cuisines",
                    "price_band",
                    "score_overall",
                    "review_count",
                    "bookmark_count",
                    "address",
                    "phones",
                    "url"
                ]
            },
            "display": {
                "component": "table",
                "properties": {}
            }
        }
    }
}

.actor/output_schema.json

{
    "actorOutputSchemaVersion": 1,
    "title": "Hong Kong restaurants",
    "description": "Open Hong Kong restaurants with review scores, review and bookmark counts, HKD price bands, cuisine and dish classifications, weekly opening hours, districts, bilingual names and addresses, phone numbers and GPS coordinates. Business listings only — no personal data.",
    "properties": {
        "restaurants": {
            "type": "string",
            "title": "Restaurants",
            "description": "All scraped restaurants as JSON: name, name_other_lang, address, address_other_lang, district, latitude, longitude, price_band, price_min_hkd, price_max_hkd, score_overall, review_count, bookmark_count, cuisines, dish_types, phones, opening_hours, open_since, status and url.",
            "template": "{{links.apiDefaultDatasetUrl}}/items"
        }
    }
}

OpenRice Scraper – Hong Kong Restaurants, Ratings & Reviews

claude_code_reviewer/openrice-scraper-en

Scrape OpenRice (Hong Kong's largest restaurant guide) without an API: name, district, cuisine, rating, review count, price range, address and phone. Bulk-paste keywords; export JSON/CSV/Excel. Great for site selection and F&B market research.

Chad

Resy Restaurants Search Scraper

stealth_mode/resy-restaurants-search-scraper

Scrape restaurant listings from Resy.com search results by city, date, and party size. Collect names, cuisines, ratings, availability slots, locations, and 35+ fields per restaurant — perfect for dining analysts, travel platforms, and hospitality researchers.

Stealth mode

Foodpanda Scraper - Restaurants, Menus & Leads

scrapesage/foodpanda-scraper

Scrape Foodpanda restaurants, menus and prices in English, the local language (e.g. Traditional Chinese) or both, plus restaurant leads: name, phone, UEN, address, geo, cuisines, rating, delivery fees. Search any area or paste restaurant URLs. Monitor mode returns new & changed restaurants only.

Scrape Sage

Foodpanda Restaurant & Menu Scraper

crawlerbros/foodpanda-scraper

Scrape Foodpanda restaurants by URL or location. Extracts name, rating, cuisines, delivery details, and full nested menus. Supports Singapore, Bangladesh, Pakistan, Hong Kong, and Malaysia.

Crawler Bros

Michelin Guide Restaurants Scraper

parseforge/michelin-restaurant-guide-scraper

Scrapes Michelin Guide restaurant listings for any city or region slug. Returns each restaurant as a flat row with its star rating, cuisine type, price range, address, and distinctions.

ParseForge

foodpanda Scraper - Restaurants & Menus (Asia-Pacific)

goat255/foodpanda-scraper

Scrape foodpanda restaurants and menus without a login. List restaurants by country and city, or pull full menus by restaurant URL. Each row has ratings, cuisines, delivery fee and time, address, dish names, prices and categories.

Goutam Soni

Deliveroo Scraper | Menus Restaurants Markets

lentic_clockss/deliveroo-scraper

Scrape Deliveroo restaurant feeds (geohash), full menus, and city/cuisine/brand SEO pages across 11 markets (UK, IE, FR, BE, IT, ES, NL, AE, KW, SG, HK). Extract drnId, titles, prices, ETA, /menu/ permalinks. Export Excel/CSV/JSON. Unofficial — not affiliated with Deliveroo.

kane liu

Foodpanda Restaurant Scraper

jungle_synthesizer/foodpanda-scraper

Scrape Foodpanda restaurants by URL or city/country. Extracts restaurant name, rating, cuisines, delivery details, address, and full nested menu with prices. Supports Singapore, Bangladesh, Pakistan, Hong Kong, Malaysia, and other markets.

BowTiedRaccoon

5.0

(1)

The Infatuation Scraper - Restaurant Reviews

lulzasaur/infatuation-scraper

Scrape The Infatuation restaurant reviews and ratings. Search by city and cuisine. Extract ratings, reviews, perfect-for tags, venue details, and neighborhood info.

lulz bot

Foodpanda Scraper — Restaurants, Menus & Prices

hipersoft/foodpanda-scraper

Scrape Foodpanda restaurants and their menus in bulk by city or coordinates: name, cuisines, rating, reviews, address, coordinates, minimum order, delivery fee, open status and menu item prices. Sweep a whole city with an optional geo-grid.

hiper soft

Foodpanda Scraper: No Login, Menus, Prices, 7 Countries

dmitrii_shifo/foodpanda-scraper

No login, no cookies, no browser, no proxy. Direct API access, so runs are fast and cheap. 7 countries in one run: PH, SG, MY, TW, HK, PK, BD. Scrape Foodpanda restaurants and full menus with prices. Pick cities from a dropdown, no URL building. Ratings, addresses, delivery fees.