# Burpple Scraper - Singapore Restaurant & Café Discovery (`scrapesage/burpple-scraper`) Actor

Scrape Burpple Singapore restaurants, cafes and hawkers by neighbourhood, cuisine or URL: name, address, phone, website, cuisine, price, reviews, wishlists, opening hours and geo. Turn F\&B venues into leads. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapesage/burpple-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 venue scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Burpple Scraper — Singapore Restaurant & Café Discovery

Extract **complete F&B venue data from [Burpple](https://www.burpple.com/sg)** — Singapore's community-driven restaurant, cafe and hawker discovery platform. Scrape by **neighbourhood, cuisine, or URL** and get every venue's **name, full address, phone, website, cuisine, price, review & wishlist counts, opening hours, geo-coordinates, images** and optional **community reviews**. Every venue is a ready-to-use **local-business lead**: a contactable F&B establishment with location, contacts and a quality score.

No login, no cookies, no browser — this actor reads Burpple's own Singapore pages directly, so the output is first-party, fast and reliable.

### Why this Burpple scraper?

Most "restaurant scrapers" give you a name and a rating and stop there. This actor pulls the **full venue record** from Burpple and ships the **richest dataset in the category** — including the contact fields that turn a listing into a lead:

| Data | Typical scrapers | This actor |
|---|---|---|
| Venue name, neighbourhood, cuisine | ✅ | ✅ |
| Price per pax (`~$NN/pax`) | partial | ✅ when published |
| Review count + wishlist count | partial | ✅ |
| **Phone number** | ❌ | ✅ when published |
| **Website** | ❌ | ✅ when published |
| **Full street address + postal code** | partial | ✅ |
| **Opening hours** (per day) | ❌ | ✅ when published |
| Latitude / longitude | ❌ | ✅ |
| Cuisine tags + Burpple Beyond / 1-for-1 deal flags | ❌ | ✅ |
| Images gallery | ❌ | ✅ |
| **Community reviews** (reviewer, level, date, dish, text, photo) | ❌ | ✅ opt-in |
| Lead score (0–100) per venue | ❌ | ✅ |
| One clean dataset, no empty columns | ❌ | ✅ |

### Use cases

- **Lead generation** — restaurants, cafes and hawkers are active buyers of POS, reservation, delivery, marketing, payroll, supply, insurance and fintech products. Score them by quality and reach (`leadScore`, `phone`, `website`) and export straight to your CRM.
- **Singapore market & competitive research** — map a neighbourhood's or cuisine's dining scene by price, popularity (reviews/wishlists) and deals; benchmark venues and track new openings.
- **Food-tech & delivery onboarding** — build target lists of independent F&B venues by area and cuisine for sales outreach.
- **Directory & app enrichment** — power dining guides, concierge tools and travel apps with standardized records, geo-coordinates and images.
- **Trend & sentiment analysis** — pull community reviews and dishes to analyse what's popular across Singapore neighbourhoods.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Burpple Scraper**, enter one or more **Cuisines** (e.g. `breakfast-and-brunch`, `ramen`) or **Neighbourhoods** (e.g. `tiong-bahru`, `bugis`), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "cuisines": ["breakfast-and-brunch", "ramen", "chicken-rice"],
    "neighbourhoods": ["tiong-bahru", "bugis"],
    "maxItems": 200,
    "includeVenueDetails": true,
    "includeReviews": false,
    "monitorMode": false
}
````

- **cuisines** — Burpple category slugs (`breakfast-and-brunch`, `coffee`, `ramen`, `dim-sum`, `bak-kut-teh`, `halal`, `fine-dining`, `buffets`, `bubble-tea`, `desserts`, `korean-bbq`, `sushi`, …). See [burpple.com/categories/sg](https://www.burpple.com/categories/sg) for the full list.
- **neighbourhoods** — Singapore neighbourhood slugs (`tiong-bahru`, `bugis`, `orchard`, `holland-village`, `tampines`, `chinatown`, …). See [burpple.com/neighbourhoods/sg](https://www.burpple.com/neighbourhoods/sg).
- **searchQueries** — free-text food keywords, resolved to the matching Burpple category page.
- **startUrls** — direct Burpple neighbourhood, category or single-venue URLs.
- **maxItems** *(default 100)* — cap on venue records for the whole run.
- **includeVenueDetails** *(default true)* — open each venue page for the full record (phone, website, full address, opening hours, geo, price, cuisine, counts, images). One fast extra request per venue.
- **includeReviews** *(default false)* — attach the most recent community reviews shown on each venue page (no extra request).
- **maxReviewsPerVenue** *(default 5)* — how many recent reviews to keep per venue.
- **maxPagesPerSource** *(default 15)* — how many extra "load more" pages to fetch per neighbourhood/cuisine.
- **monitorMode** *(default false)* — emit only venues not seen in previous runs (see below).

### Output

One record per venue (`type: "venue"`):

```json
{
    "type": "venue",
    "venueId": "125991",
    "slug": "marutama-ramen-central-clarke-quay",
    "url": "https://www.burpple.com/marutama-ramen-central-clarke-quay",
    "name": "Marutama Ramen (Clarke Quay Central)",
    "neighbourhood": "Clarke Quay",
    "city": "Singapore",
    "country": "Singapore",
    "cuisines": ["Ramen", "Japanese"],
    "primaryCuisine": "Ramen",
    "priceRange": "~$20/pax",
    "priceValue": 20,
    "hasBeyondDeal": false,
    "reviewCount": 75,
    "wishlistedCount": 95,
    "address": "6 Eu Tong Sen Street #03-90/91 Clarke Quay Central",
    "postalCode": "059817",
    "latitude": 1.2889402,
    "longitude": 103.8463092,
    "phone": "+65 65348090",
    "website": "https://marutama.com.sg/",
    "openingHoursText": "Monday: 11:00am - 10:00pm; ...",
    "featuredImage": "https://burpple-image.burpple.com/foods/data2005394_original.",
    "images": ["https://burpple-image.burpple.com/foods/..."],
    "leadScore": 84,
    "sourceType": "category",
    "sourceQuery": "ramen",
    "scrapedAt": "2026-06-26T04:00:00.000Z"
}
```

With **includeReviews** on, each record also carries a `reviews` array (`author`, `authorLevel`, `authorReviewCount`, `date`, `tags`, `dish`, `text`, `photo`).

Use the **Venues** and **Leads (contacts)** dataset views to switch between column sets.

#### What to expect (field coverage)

Verified across multiple cuisines and neighbourhoods:

| Field | Coverage |
|---|---|
| name, neighbourhood, address, latitude/longitude, review count, wishlist count, images, Burpple URL | ~100% |
| **website**, cuisine, price (`~$NN/pax`), opening hours | present for most **established** cafes/restaurants |
| **phone** | ~60–75% (venue-supplied; many mall outlets & hawker stalls list none) |
| reviews | when `includeReviews` is on |

Burpple is **community-driven**: established cafes and restaurants carry rich price/phone/cuisine/hours, while informal **hawker stalls** often only have a name, address and reviews. A blank field means Burpple doesn't publish that value for that venue — not that scraping failed. Nothing is dropped, so you always get the richest record available. Note: Burpple uses **review and wishlist counts** for popularity, not a star rating — so `ratingValue` is intentionally not published; sort by `reviewCount`, `wishlistedCount` or `leadScore` instead.

### Monitoring mode — only new venues

Turn on **monitorMode** to make the actor remember which venues it has already returned and emit **only venues not seen in previous runs** — perfect for tracking new restaurant & cafe openings in a neighbourhood or cuisine. It stores seen venue ids in a named key-value store (`monitorStoreName`, one per tracked area/cuisine).

This **complements [Apify Schedules](https://docs.apify.com/platform/schedules)** and does not conflict with them: Schedules decide *when* the actor runs (e.g. every morning), and monitoring mode decides *what is new* in each run. Use both together for a daily feed of just-opened venues in your target areas.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to monitor new openings or refresh contacts and reviews.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/burpple-scraper').call({
    cuisines: ['breakfast-and-brunch'],
    neighbourhoods: ['tiong-bahru'],
    maxItems: 200,
    includeVenueDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} venues`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new venue leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored area adds new venues.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list every cafe in Tiong Bahru with phone and website" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **Singapore F\&B, local-business & lead-gen stack**:

- **[Resy Scraper](https://apify.com/scrapesage/resy-scraper)** — premium restaurant reservations, ratings and contacts.
- **[foodpanda Scraper](https://apify.com/scrapesage/foodpanda-scraper)** — food-delivery restaurants, menus and prices (Singapore & APAC).
- **[Zomato Scraper](https://apify.com/scrapesage/zomato-scraper)** — restaurants, ratings and reviews.
- **[UberEats Scraper](https://apify.com/scrapesage/ubereats-scraper)** — restaurants, menus and delivery data.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-with-contact-details)** — local businesses with phone, website and reviews.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials from any website.
- **[99.co Property Scraper](https://apify.com/scrapesage/99-co-property-scraper)** — Singapore property listings and agent leads.
- **[EdgeProp.sg Scraper](https://apify.com/scrapesage/edgeprop-singapore-scraper)** — Singapore property and agent leads.
- **[SGCarMart Scraper](https://apify.com/scrapesage/sgcarmart-used-car-scraper)** — Singapore used-car listings and dealer leads.
- **[Singapore Company Scraper](https://apify.com/scrapesage/singapore-company-scraper)** — UEN, registry and business leads.
- **[StreetDirectory Scraper](https://apify.com/scrapesage/streetdirectory-business-scraper)** — Singapore business directory leads.
- **[MyCareersFuture Scraper](https://apify.com/scrapesage/mycareersfuture-scraper)** — Singapore jobs, salaries and leads.

### Tips

- **Whole-area coverage**: put the neighbourhood slug in `neighbourhoods` (e.g. `tiong-bahru`) and raise `maxPagesPerSource` for deeper coverage.
- **Cuisine targeting**: use exact Burpple category slugs in `cuisines` (`ramen`, `chicken-rice`, `breakfast-and-brunch`) for the cleanest, richest venues.
- **Cost control**: turn off `includeVenueDetails` for a fast, cheap listing pass (name, slug, address, image); turn it on to add phone, website, hours, geo, price and reviews.
- **Best leads first**: sort the dataset by `leadScore` to surface contactable, popular venues at the top.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only newly listed venues.

### FAQ

**How do I scrape every venue in a neighbourhood?** Put the neighbourhood slug in `neighbourhoods` (e.g. `bugis`) and raise `maxPagesPerSource`. Find slugs at [burpple.com/neighbourhoods/sg](https://www.burpple.com/neighbourhoods/sg).

**Does it need a Burpple account or API key?** No. This actor reads Burpple's own public Singapore pages — the same data the website shows — with no login, cookie or key.

**Where do the phone and website come from?** From the venue's own Burpple page. They are venue-/community-supplied, so most established cafes and restaurants have them; many hawker stalls do not. When a venue doesn't list one, the field is simply absent.

**Is there a star rating?** Burpple ranks venues by community recommendations, not stars, so it does not publish a numeric rating. This actor returns `reviewCount` and `wishlistedCount` (popularity signals) and, optionally, the review text itself.

**Can I get the reviews?** Yes — turn on `includeReviews` to attach the recent reviews shown on each venue page (reviewer, level, date, dish, text, photo).

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping Burpple legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. PDPA/GDPR for personal data) and Burpple's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `cuisines` (type: `array`):

Burpple category slugs to scrape, e.g. "breakfast-and-brunch", "coffee", "ramen", "chicken-rice", "dim-sum", "bak-kut-teh", "halal", "fine-dining", "buffets", "bubble-tea", "desserts", "korean-bbq", "sushi". See burpple.com/categories/sg for the full list. One per row.

## `neighbourhoods` (type: `array`):

Singapore neighbourhood slugs to scrape every venue in, e.g. "tiong-bahru", "bugis", "orchard", "holland-village", "tampines", "chinatown". See burpple.com/neighbourhoods/sg for the full list. One per row.

## `searchQueries` (type: `array`):

Free-text food keywords (e.g. "korean bbq", "mala", "brunch"). Each is resolved to the matching Burpple category page. For best results use the exact category slugs in the Cuisines field above. One per row.

## `startUrls` (type: `array`):

Direct Burpple URLs — a neighbourhood page, a category page, or a single venue page (e.g. https://www.burpple.com/tiong-bahru-bakery , https://www.burpple.com/categories/sg/cafes ). One per row.

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

Cap on venue records across the whole run.

## `includeVenueDetails` (type: `boolean`):

Open each venue's Burpple page for the complete record: phone, website, full address, opening hours, geo-coordinates, price, cuisine tags, review & wishlist counts and images. One extra fast request per venue. Off = the fast, cheap listing record (name, slug, address, image).

## `includeReviews` (type: `boolean`):

Also attach the most recent community reviews shown on each venue page (reviewer name, level, date, dish, text and photo). Requires venue details to be on. No extra request — reviews are read from the same venue page.

## `maxReviewsPerVenue` (type: `integer`):

How many recent reviews to keep per venue when 'Include reviews' is on.

## `maxPagesPerSource` (type: `integer`):

How many extra 'load more' pages to fetch per neighbourhood / category (each adds ~12 venues). Raise for deeper coverage of a single area or cuisine.

## `deduplicate` (type: `boolean`):

Skip a venue already emitted earlier in the same run (common when one venue appears under several cuisines or neighbourhoods).

## `monitorMode` (type: `boolean`):

Remember which venues were already returned and emit ONLY venues not seen in previous runs. Pairs with Apify Schedules to track new restaurant & cafe openings over time (it does not conflict with Schedules — Schedules decide when to run, this decides what is new).

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' venue ids for monitoring mode. Use a different name per tracked area/cuisine to keep histories separate.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Lower it if you see transient blocks; raise it for speed.

## `proxyConfiguration` (type: `object`):

Proxy settings. Burpple is read over Apify Residential proxy (datacenter IPs are blocked), with automatic IP rotation; the default works well. Blocked requests retry automatically on a fresh IP.

## Actor input object example

```json
{
  "cuisines": [
    "breakfast-and-brunch"
  ],
  "maxItems": 100,
  "includeVenueDetails": true,
  "includeReviews": false,
  "maxReviewsPerVenue": 5,
  "maxPagesPerSource": 15,
  "deduplicate": true,
  "monitorMode": false,
  "monitorStoreName": "burpple-scraper-monitor",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped venue records in the default dataset. Switch between the Venues and Leads views to focus the columns.

# 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 = {
    "cuisines": [
        "breakfast-and-brunch"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/burpple-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 = {
    "cuisines": ["breakfast-and-brunch"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/burpple-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 '{
  "cuisines": [
    "breakfast-and-brunch"
  ],
  "maxItems": 100
}' |
apify call scrapesage/burpple-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Burpple Scraper - Singapore Restaurant & Café Discovery",
        "description": "Scrape Burpple Singapore restaurants, cafes and hawkers by neighbourhood, cuisine or URL: name, address, phone, website, cuisine, price, reviews, wishlists, opening hours and geo. Turn F&B venues into leads. Export to JSON, CSV or Excel.",
        "version": "0.1",
        "x-build-id": "DWzTP7Z12muiR84Dq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~burpple-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-burpple-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/scrapesage~burpple-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-burpple-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/scrapesage~burpple-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-burpple-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": {
                    "cuisines": {
                        "title": "Cuisines / categories",
                        "type": "array",
                        "description": "Burpple category slugs to scrape, e.g. \"breakfast-and-brunch\", \"coffee\", \"ramen\", \"chicken-rice\", \"dim-sum\", \"bak-kut-teh\", \"halal\", \"fine-dining\", \"buffets\", \"bubble-tea\", \"desserts\", \"korean-bbq\", \"sushi\". See burpple.com/categories/sg for the full list. One per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "neighbourhoods": {
                        "title": "Neighbourhoods (optional)",
                        "type": "array",
                        "description": "Singapore neighbourhood slugs to scrape every venue in, e.g. \"tiong-bahru\", \"bugis\", \"orchard\", \"holland-village\", \"tampines\", \"chinatown\". See burpple.com/neighbourhoods/sg for the full list. One per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries (optional)",
                        "type": "array",
                        "description": "Free-text food keywords (e.g. \"korean bbq\", \"mala\", \"brunch\"). Each is resolved to the matching Burpple category page. For best results use the exact category slugs in the Cuisines field above. One per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Direct Burpple URLs — a neighbourhood page, a category page, or a single venue page (e.g. https://www.burpple.com/tiong-bahru-bakery , https://www.burpple.com/categories/sg/cafes ). One per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max venues",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Cap on venue records across the whole run.",
                        "default": 100
                    },
                    "includeVenueDetails": {
                        "title": "Enrich with full venue details (phone, website, hours, geo, price)",
                        "type": "boolean",
                        "description": "Open each venue's Burpple page for the complete record: phone, website, full address, opening hours, geo-coordinates, price, cuisine tags, review & wishlist counts and images. One extra fast request per venue. Off = the fast, cheap listing record (name, slug, address, image).",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Also attach the most recent community reviews shown on each venue page (reviewer name, level, date, dish, text and photo). Requires venue details to be on. No extra request — reviews are read from the same venue page.",
                        "default": false
                    },
                    "maxReviewsPerVenue": {
                        "title": "Max reviews per venue",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many recent reviews to keep per venue when 'Include reviews' is on.",
                        "default": 5
                    },
                    "maxPagesPerSource": {
                        "title": "Max pages per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many extra 'load more' pages to fetch per neighbourhood / category (each adds ~12 venues). Raise for deeper coverage of a single area or cuisine.",
                        "default": 15
                    },
                    "deduplicate": {
                        "title": "Deduplicate venues",
                        "type": "boolean",
                        "description": "Skip a venue already emitted earlier in the same run (common when one venue appears under several cuisines or neighbourhoods).",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new venues",
                        "type": "boolean",
                        "description": "Remember which venues were already returned and emit ONLY venues not seen in previous runs. Pairs with Apify Schedules to track new restaurant & cafe openings over time (it does not conflict with Schedules — Schedules decide when to run, this decides what is new).",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the 'already seen' venue ids for monitoring mode. Use a different name per tracked area/cuisine to keep histories separate.",
                        "default": "burpple-scraper-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower it if you see transient blocks; raise it for speed.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Burpple is read over Apify Residential proxy (datacenter IPs are blocked), with automatic IP rotation; the default works well. Blocked requests retry automatically on a fresh IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
