# Happycow Restaurants Search Scraper (`stealth_mode/happycow-restaurants-search-scraper`) Actor

Scrape vegan and vegetarian restaurant listings from HappyCow.net by location. Collect names, ratings, cuisine tags, addresses, coordinates, and 19+ fields per listing — perfect for food researchers, app developers, and plant-based travel guides.

- **URL**: https://apify.com/stealth\_mode/happycow-restaurants-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are 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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## HappyCow Restaurant Search Scraper: Extract Vegan & Vegetarian Listings

---

### What Is HappyCow.net?

HappyCow.net is one of the world's largest directories for vegan, vegetarian, and vegan-friendly restaurants, with listings across hundreds of countries. It is the go-to resource for plant-based travelers and food businesses. The **HappyCow Restaurant Search Scraper** automates extraction from HappyCow search and location pages, turning paginated listings into clean, structured datasets.

---

### Overview

This scraper targets HappyCow's restaurant list pages (browsable by city, region, or country) and returns detailed records per venue. It is built for:

- **App developers** building plant-based dining finders
- **Food researchers** analyzing vegan restaurant density by region
- **Travel content creators** compiling city guides
- **Marketers** identifying partnership or advertising opportunities in the vegan space

Key features: configurable item limits, fault-tolerant URL handling, and support for paginated list URLs.

---

### Input Format

```json
{
  "ignore_url_failures": true,
  "max_items_per_url": 200,
  "urls": [
    "https://www.happycow.net/europe/england/london/?page=1"
  ]
}
````

| Field | Type | Description |
|---|---|---|
| `urls` | `array` | URLs of HappyCow restaurant list pages to scrape. Add one per line or use Bulk edit. Example: `https://www.happycow.net/europe/england/london/?page=1` |
| `max_items_per_url` | `integer` | Maximum number of restaurant records to collect per URL. Default: `20`. Set higher (e.g., `200`) for full city coverage. |
| `ignore_url_failures` | `boolean` | If `true`, the scraper continues running when a URL fails instead of stopping the entire run. Recommended: `true` for bulk jobs. |

> **Tip:** HappyCow paginates results. To collect all listings for a city, add multiple page URLs: `?page=1`, `?page=2`, etc., or increase `max_items_per_url` to cover the full result set.

***

### Output Format

**Sample output**

```json
{
  "id": 364629,
  "name": "ARKET",
  "rating": 3.5,
  "review_count": 2,
  "category": "Vegetarian Restaurant",
  "cuisine_tags": "ARKET\n3.5\n(2)\n Vegetarian Restaurant \nLoading\nLacto, Ovo, Bakery, European, New Nordic\nA vegetarian cafe inside a clothes and household shop. Part of a chain based in Sweden. Described as a 'New Nordic vegetarian café'. Serves pastries, sandwiches and snacks, some of which are vegan (yet are not clearly labeled).",
  "price_range": 3,
  "status": "Loading",
  "description": "A vegetarian cafe inside a clothes and household shop. Part of a chain based in Sweden. Described as a 'New Nordic vegetarian café'. Serves pastries, sandwiches and snacks, some of which are vegan (yet are not clearly labeled).",
  "address": "27-29 Long Acre, Covent Garden, London, England",
  "phone": "+44-2034029160",
  "latitude": 51.512562,
  "longitude": -0.125056,
  "review_url": "https://www.happycow.net/reviews/arket-london-364629",
  "image_url": "https://images.happycow.net/venues/500/36/46/hcmp364629_2278056.jpeg",
  "maps_url": "https://www.google.com/maps?q=51.512562,-0.125056",
  "is_top": false,
  "is_new": false,
  "is_partner": false,
  "from_url": "https://www.happycow.net/europe/england/london/?page=2"
}
```

Each restaurant record contains up to 19 fields:

#### Identification

| Field | Meaning |
|---|---|
| `ID` | HappyCow's internal unique identifier for the venue |
| `Name` | Restaurant name as displayed on HappyCow |
| `Review URL` | Direct link to the restaurant's HappyCow listing page |
| `Maps URL` | Google Maps link generated from the venue's coordinates |

#### Ratings & Social Proof

| Field | Meaning |
|---|---|
| `Rating` | Average user rating (typically on a 0–5 scale) |
| `Review Count` | Total number of user reviews submitted |
| `Is Top` | Boolean flag — venue has been highlighted as a top pick on HappyCow |
| `Is New` | Boolean flag — recently added listing |
| `Is Partner` | Boolean flag — venue has a paid or featured partner status with HappyCow |

#### Classification

| Field | Meaning |
|---|---|
| `Category` | Primary venue type (e.g., `vegan`, `vegetarian`, `vegan-friendly`) |
| `Cuisine Tags` | Array of cuisine styles associated with the venue (e.g., `Italian`, `Asian Fusion`, `Raw Food`) |
| `Price Range` | Approximate cost indicator (e.g., `$`, `$$`, `$$$`) |
| `Status` | Current operational status of the venue (e.g., open, closed, permanently closed) |

#### Details & Description

| Field | Meaning |
|---|---|
| `Description` | Short venue description or summary from the listing |
| `Image URL` | URL of the venue's primary photo |

#### Location

| Field | Meaning |
|---|---|
| `Address` | Full street address as listed on HappyCow |
| `Phone` | Contact phone number, if available |
| `Latitude` | Geographic latitude coordinate |
| `Longitude` | Geographic longitude coordinate |

***

### How to Use

1. **Find list URLs** — Browse HappyCow by city or region (e.g., `happycow.net/europe/france/paris/`). Copy the URL from the browser.
2. **Add pages** — For cities with many listings, add multiple paginated URLs (`?page=1`, `?page=2`, ...).
3. **Set item limit** — Use `max_items_per_url: 200` for thorough coverage; reduce for quick tests.
4. **Enable fault tolerance** — Keep `ignore_url_failures: true` to prevent single failed pages from interrupting bulk runs.
5. **Export** — Download results as JSON, CSV, or Excel.

**Common issues:**

- Supplying a restaurant *detail* URL instead of a *list* URL will return no results. Always use category/city browse pages.
- Some fields (e.g., `Phone`, `Price Range`) may be absent if the venue owner hasn't filled them in.

***

### Use Cases & Business Value

- **Travel apps:** Integrate geolocated vegan dining data into city guides or map features
- **Market research:** Measure vegan restaurant growth by city or country over time
- **Lead generation:** Build outreach lists of plant-based venues for food-tech or delivery platforms
- **Content production:** Automatically populate "best vegan spots" articles with live data

***

### Conclusion

The **HappyCow Restaurant Search Scraper** transforms paginated HappyCow browse pages into structured, geocoded venue datasets in minutes. With 19 output fields covering ratings, location, cuisine, and listing flags, it provides everything needed to build applications, conduct research, or power content — without any manual data entry.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the restaurants list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.happycow.net/europe/england/london/?page=1"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.happycow.net/europe/england/london/?page=1"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/happycow-restaurants-search-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 = {
    "urls": ["https://www.happycow.net/europe/england/london/?page=1"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/happycow-restaurants-search-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 '{
  "urls": [
    "https://www.happycow.net/europe/england/london/?page=1"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/happycow-restaurants-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Happycow Restaurants Search Scraper",
        "description": "Scrape vegan and vegetarian restaurant listings from HappyCow.net by location. Collect names, ratings, cuisine tags, addresses, coordinates, and 19+ fields per listing — perfect for food researchers, app developers, and plant-based travel guides.",
        "version": "0.0",
        "x-build-id": "WcTXsVoSGo6v3f2Ny"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~happycow-restaurants-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-happycow-restaurants-search-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/stealth_mode~happycow-restaurants-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-happycow-restaurants-search-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/stealth_mode~happycow-restaurants-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-happycow-restaurants-search-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": {
                    "urls": {
                        "title": "URLs of the restaurants list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the restaurants list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
