# Tock Scraper \[$3/1K💰] | Restaurant Venues | Availability (`ahmed_jasarevic/exploretock-scraper`) Actor

Extract restaurant, bar and venue data from Tock (exploretock.com) — name, city, cuisine, price tier, experience and offer counts, bookable dates and reservation availability — as structured JSON. Built for dining market research, availability monitoring and F\&B lead generation. $3 per 1,000 venues.

- **URL**: https://apify.com/ahmed_jasarevic/exploretock-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.90 / 1,000 venues

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

Learn more: https://docs.apify.com/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

## Tock (exploretock.com) Scraper — Restaurant & Venue Data

Extract restaurant, bar and venue data from Tock (exploretock.com) — venue name, city, neighbourhood, cuisine, price tier, experience and offer counts, bookable dates, slot counts and earliest availability — as structured JSON, from $3 per 1,000 venues.

**Built for:**

- Restaurant market research and competitive dining analysis
- Reservation-availability monitoring for high-demand venues
- Building a structured venue / dining database
- F\&B lead generation and partnership research
- Travel and concierge booking research

### Scrape Tock Venues & Reservation Availability

Tock (exploretock.com) lists thousands of restaurants, wineries and experiences with their bookable inventory. This actor works in two modes: a **venues** mode that collects venue profiles across cities, and an **availability** mode that pulls open reservation slots for a chosen date, party size and time window. Each row is a clean venue or slot record, so you can build city-wide dining databases and track how quickly high-demand venues fill up.

### How It Works

![How the Tock Scraper works: city and venue queries become venue profiles or live reservation slots with cuisine, price tier and availability.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-exploretock-scraper)

The Actor launches a headful Chrome browser, lets Cloudflare's standard browser check complete once, then fetches city and venue pages inside the same browser tab. Pages are parsed from the server-rendered Redux store, so no per-page rendering or clicking is needed. Venue mode enumerates city and profile data; availability mode queries a chosen date, party size and time window.

Venue rows carry name, city, neighbourhood, cuisine, price tier, experience and offer counts. Availability rows add bookable dates, slot counts and the earliest open time for the target venue.

Tock's site is served behind Cloudflare, so the actor reads the same server-rendered pages a real browser sees instead of fragile private API endpoints:

1. **Venue discovery** — reads Tock's city and venue listing data to enumerate venues by `citySlugs` or `venueSlugs`, capturing name, location, cuisine, price tier and experience/offer structure.
2. **Availability lookup** — for each target venue, queries the public availability surface with your `date`, `partySize` and time window and returns each open slot (time, experience, price, party size).
3. **Enrichment** — follows each venue's public profile for the detail fields shown in the output table.

By default the Actor uses **headful Chrome**: one Cloudflare check at startup, then fast in-page fetches that reuse the browser clearance. A residential proxy is optional but recommended for large or scheduled runs; if the current IP gets hard-blocked, the Actor rotates to a **fresh sticky proxy IP** and relaunches the browser. For troubleshooting, `fetchMode: "http"` switches to the lighter curl-impersonate path.

### Input Parameters

| Field                 | Type    | Required | Default               | Notes                                                                                                          |
| --------------------- | ------- | -------- | --------------------- | -------------------------------------------------------------------------------------------------------------- |
| `scrapeMode`          | string  | No       | `venues`              | `venues` = collect venue profiles; `availability` = pull open reservation slots.                               |
| `fetchMode`           | string  | No       | `browser`             | `browser` = headful Chrome, one Cloudflare solve then in-page SSR fetches; `http` = curl-impersonate fallback. |
| `citySlugs`           | array   | No       | `["chicago"]`         | Tock city slugs used for venue discovery (venues mode) or one search per city (availability mode).             |
| `venueSlugs`          | array   | No       | `[]`                  | Venues mode only. Specific Tock venue slugs or URLs to target; they take priority over `citySlugs`.            |
| `date`                | string  | No       | today (UTC)           | Availability mode date in `YYYY-MM-DD`.                                                                        |
| `time`                | string  | No       | `19:00`               | Availability mode preferred time, 24-hour `HH:mm`.                                                             |
| `partySize`           | integer | No       | `2`                   | Party size for availability lookups.                                                                           |
| `searchType`          | string  | No       | `DINE_IN_EXPERIENCES` | `DINE_IN_EXPERIENCES` or `DINE_IN`.                                                                            |
| `maxVenues`           | integer | No       | `25`                  | Maximum venues (venues mode) or availability rows (availability mode); free access capped at 10.               |
| `includeAvailability` | boolean | No       | `true`                | In venues mode, include experiences, prices, open dates and time slots (adds billed `Availability` events).    |
| `maxConcurrency`      | integer | No       | `5`                   | HTTP fallback only. Browser mode uses one Chrome tab and serialized in-page fetches.                           |
| `requestDelayMs`      | integer | No       | `250`                 | Delay between requests inside one worker.                                                                      |
| `retryCooldownSecs`   | integer | No       | `5`                   | Cooldown before the final retry pass for pages still blocked after automatic IP rotation.                      |
| `proxy`               | object  | No       | off                   | Standard Apify proxy picker; browser mode rotates at browser level when an IP is blocked.                      |

### Output Fields

| Field                                        | Description                                                      |
| -------------------------------------------- | ---------------------------------------------------------------- |
| `name`, `slug`, `businessId`                 | Venue name, Tock slug and business ID                            |
| `city`, `neighborhood`                       | City and neighbourhood                                           |
| `cuisine`, `priceTier`                       | Cuisine category and price tier                                  |
| `experienceCount`, `offerCount`              | Number of experiences / offers listed                            |
| `bookableDates`, `slotCount`, `earliestSlot` | Bookable dates, open slot count and earliest available slot time |
| `dataQuality`                                | Record-completeness indicator (`full` or `listing-only`)         |
| `url`, `scrapedAt`                           | Tock venue URL and ISO timestamp                                 |

**View:** the Output tab has a **Venues** table (name, city, neighbourhood, cuisine, price tier, experiences, offers, bookable dates, slots, slug).

### Example Input

```json
{
    "scrapeMode": "venues",
    "citySlugs": ["new-york", "chicago"],
    "maxVenues": 10,
    "includeAvailability": false
}
```

Availability run:

```json
{
    "scrapeMode": "availability",
    "citySlugs": ["chicago"],
    "date": "2026-11-01",
    "time": "19:00",
    "partySize": 2
}
```

### Example Output

```json
{
    "name": "Alinea",
    "slug": "alinea",
    "businessId": "12345",
    "city": "Chicago",
    "neighborhood": "Lincoln Park",
    "cuisine": "Contemporary American",
    "priceTier": "$$$$",
    "experienceCount": 3,
    "offerCount": 3,
    "bookableDates": ["2026-11-01", "2026-11-02"],
    "slotCount": 6,
    "earliestSlot": "2026-11-01T18:15:00-05:00",
    "dataQuality": "full",
    "url": "https://www.exploretock.com/alinea",
    "scrapedAt": "2026-10-20T09:00:00.000Z"
}
```

### Automate Tock Availability Monitoring With Schedules & Webhooks

- **High-demand availability watch:** schedule `scrapeMode: availability` daily for your target venues and alert on `earliestSlot` — recurring runs also improve this actor's Store recommendation signals.
- **City dining database:** schedule a weekly `venues` run per `citySlug` to build and refresh a structured F\&B directory.
- **Competitive menu research:** track `experienceCount`/`offerCount` and `priceTier` changes across a set of venues.
- **Concierge / travel feeds:** webhook new availability into a booking or CRM system.

### Related Actors

- [OpenTable Scraper — Restaurant Data & Availability](https://apify.com/parseforge/opentable-scraper) — the largest OpenTable actor; the mainstream comparator to Tock's premium dining inventory.
- [OpenTable Scraper — Restaurants & Reservation Slots](https://apify.com/shahidirfan/opentable-scraper) — alternative OpenTable extraction.
- [Resy Availability API — Reservation Slots](https://apify.com/clearpath/resy-availability-api) — Resy availability for another major reservation platform.
- [OpenTable Restaurant Scraper — Menu & Availability Data](https://apify.com/rl1987/opentable-api-scraper) — lightweight OpenTable API-style extraction.
- [Restaurant Lead Finder — Restaurant & Owner Data](https://apify.com/seibs.co/restaurant-lead-finder) — restaurant lead-gen dataset for outreach.

### Frequently Asked Questions

#### Why use this actor instead of the official API?

Tock **does** offer an official API, but it is **partner-only**: it requires a Premium or Premium Unlimited plan, an API key issued via `integrate@tockhq.com`, and it is read-only — the official API supports **data exports and a reservation webhook, not reservation creation or cancellation**. It is therefore not a general-purpose public data API for market research, and it is not open to anyone who just wants venue or availability data. This actor reads the same public venue and availability surfaces the Tock frontend uses, with no partner agreement and pay-per-result pricing.

#### What are the alternatives to Tock data?

1. **OpenTable** — the mainstream reservation platform, with no public consumer API either (bot-protected); several Apify actors cover it.
2. **Resy** — another reservation platform; the Resy Availability actor here covers slots.
3. **The official Tock partner API** — read-only exports plus webhooks, gated behind a Premium plan.
4. **Availability aggregators** — third-party trackers exist but are per-platform and paid.
5. **This actor** — public Tock venue and availability data, pay-per-result.

#### Is there a free Tock API?

No free public API. Tock's official API is partner-only (Premium plan + issued key). This actor uses the public site data — free Apify accounts get a 10-venue preview, paid plans get the full run up to `maxVenues`.

#### What's the difference between venues and availability mode?

`venues` mode collects venue profiles (name, city, cuisine, price tier, experience/offer counts) and can also fetch slots with `includeAvailability: true`. `availability` mode is slot-focused: give it `citySlugs`, a `date`, a `time` and a `partySize` and it returns open reservation slots per venue in that city.

#### Can I target one specific restaurant?

Yes — in venues mode pass `venueSlugs` (e.g. `["alinea"]`). `venueSlugs` take priority over `citySlugs` when both are set. Availability mode searches by city, so it ignores `venueSlugs`.

#### Do I need a proxy?

Not for a quick test: headful Chrome clears Cloudflare's standard browser check even on a shared IP. For large or scheduled runs, a residential proxy is recommended so that a hard-blocked IP is swapped automatically and the browser relaunches on a fresh sticky IP.

### For AI Agents & LLM Apps

**Purpose:** returns Tock (exploretock.com) venue records — and optionally reservation availability slots — for given city or venue slugs, one row per venue/slot with name, city, neighbourhood, cuisine, price tier, experience/offer counts and bookable dates.

**Minimal input:**

```json
{ "scrapeMode": "venues", "citySlugs": ["new-york"], "maxVenues": 10 }
```

**Availability variant:**

```json
{ "scrapeMode": "availability", "citySlugs": ["chicago"], "date": "2026-11-01", "time": "19:00", "partySize": 2 }
```

**Output fields:** name, businessId, dataQuality, slug, city, neighborhood, cuisine, priceTier, experienceCount, bookableDates, offerCount, slotCount, earliestSlot, url, scrapedAt.

**Behaviors an agent should know:**

- `venueSlugs` **take priority over** `citySlugs` when both are set (venues mode only).
- `maxVenues` defaults to **25** and free access is capped at 10 venues regardless of the value set.
- `includeAvailability` is **on by default** in venues mode and adds billed `Availability` events **per venue**.
- `date`/`time`/`partySize`/`searchType` only affect availability mode; they are ignored by pure venue collection.
- `fetchMode` defaults to `browser` (headful Chrome): one Cloudflare solve, then in-page SSR fetches. Use `http` only for troubleshooting.
- A residential proxy is recommended for large or scheduled runs; a hard-blocked IP is swapped automatically and the browser relaunches on a fresh sticky IP.

**Billing:** pay-per-event — `Venue` $0.003 per venue and `Availability` $0.003 per availability lookup (minimum charge $0.02), plus an Actor start event; free accounts get a 10-venue preview.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Tock or Tock LLC (exploretock.com). It reads only publicly available venue and availability data through the same pages the Tock frontend serves — no login and no account access; the browser only completes Cloudflare's standard browser check. No reservations are created or cancelled. Any business contact or venue data returned should not be used for unsolicited commercial outreach in violation of applicable law. Users are responsible for their own compliance with Tock's Terms of Service, `robots.txt` and applicable data-protection law when storing, redistributing or automating access to the collected data.

### SEO Keywords

tock scraper, exploretock scraper, tock api, tock api alternative, restaurant data scraper, restaurant availability data, restaurant reservation data, opentable alternative, resy alternative, restaurant lead generation, dining market research, venue data scraper, restaurant database, reservation availability monitoring, restaurant price tier data, food and beverage data, restaurant market research, bookable slots data, luxury dining data, restaurant directory data, city dining database, restaurant competitive analysis, fine dining data, hospitality market data

# Actor input Schema

## `scrapeMode` (type: `string`):

Venue profiles: full venue data, experiences, prices, and optional availability. Availability search: venues with bookable slots for one date, time, and party size.

## `citySlugs` (type: `array`):

Tock metro slugs, e.g. chicago, new-york-city, portland, san-francisco. Venue mode discovers venues from each city page; availability mode runs one search per city.

## `venueSlugs` (type: `array`):

Venue mode only. Direct venue slugs (e.g. alinea) or exploretock.com venue URLs. These are scraped in addition to city discovery. Availability mode ignores this field.

## `date` (type: `string`):

Availability mode only. Reservation date in YYYY-MM-DD format. Leave empty for today's UTC date. Tock returns slots in a window around the chosen time, not the whole day.

## `partySize` (type: `integer`):

Availability mode only. Number of guests per reservation.

## `time` (type: `string`):

Availability mode only. 24-hour HH:mm, e.g. 19:00. Tock returns slots in a window around this time.

## `searchType` (type: `string`):

Dine-in + experiences is the default and returns restaurants, bars, wineries, and bookable experiences. Dine-in only restricts the search to standard reservations.

## `fetchMode` (type: `string`):

Headful Chrome clears the Cloudflare challenge once, then fetches server-rendered pages directly inside the browser (recommended, fast and reliable). HTTP only skips the browser and uses curl-impersonate; it starts faster but Cloudflare blocks more requests.

## `maxVenues` (type: `integer`):

Venue mode: maximum venue detail pages. Availability mode: maximum availability rows. Free users are capped at 10.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on HTTP requests. Venue mode counts city discovery plus venue pages; availability mode counts one search per city.

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

HTTP fallback only. With a proxy, each worker gets one sticky proxy IP and cookie jar and rotates to a fresh IP when challenged. Browser mode always uses one Chrome tab and serialized in-page fetches.

## `requestDelayMs` (type: `integer`):

Pause before each request inside a session. Lower is faster but may increase Cloudflare challenges; challenged requests automatically rotate to a fresh proxy IP. 0 disables the extra delay.

## `retryCooldownSecs` (type: `integer`):

How long to wait before the final retry pass for pages that are still blocked after an automatic proxy IP rotation. Short cooldowns are usually enough because blocked workers already switched IPs.

## `includeAvailability` (type: `boolean`):

Venue mode only. Include experiences with prices and party-size limits, plus the venue's open dates and time slots. Availability mode always returns offers and slots.

## `proxy` (type: `object`):

Tock uses Cloudflare. Browser mode clears the challenge on the platform IP; a residential proxy adds a clean sticky IP and automatic browser-level rotation if that IP gets blocked. Without a proxy, a hard-blocked platform IP cannot be rotated.

## Actor input object example

```json
{
  "scrapeMode": "venues",
  "citySlugs": [
    "chicago"
  ],
  "date": "",
  "partySize": 2,
  "time": "19:00",
  "searchType": "DINE_IN_EXPERIENCES",
  "fetchMode": "browser",
  "maxVenues": 25,
  "maxRequestsPerCrawl": 200,
  "maxConcurrency": 5,
  "requestDelayMs": 250,
  "retryCooldownSecs": 5,
  "includeAvailability": true,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "citySlugs": [
        "chicago"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/exploretock-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 = {
    "citySlugs": ["chicago"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/exploretock-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 '{
  "citySlugs": [
    "chicago"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/exploretock-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/exploretock-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/IjiBBisen7Wk1cQva/builds/9KMvPZEYQ9BaVfixP/openapi.json