# Foodora Scraper — Restaurants, Menus & Prices (`hipersoft/foodora-scraper`) Actor

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

- **URL**: https://apify.com/hipersoft/foodora-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0015 / vendor scraped

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 🛵 Foodora Scraper — Restaurants, Menus & Prices

Scrape **Foodora restaurants and their menus in bulk** as clean, structured **JSON, CSV, Excel or XML**. Give it a **city** (Stockholm, Gothenburg, Malmö, Vienna, Graz, Oslo, Bergen, Prague, Brno, Budapest, Debrecen) or exact **coordinates**, and it returns one tidy row per restaurant — name, **cuisines, rating, reviews, address, coordinates, minimum order, delivery fee** and open status — plus, on request, **every menu item with its price**. Sweep a whole city with an optional **geo-grid**. Perfect for food-market research, competitor and price monitoring, lead generation and automation.

### What does Foodora Scraper do?

This actor turns Foodora's restaurant listings into a ready-to-use dataset. Point it at a city or a latitude/longitude, and it collects every restaurant delivering to that area with rich, structured details. Turn on **Include menu items** and it also pulls each restaurant's full menu — categories, dish names, descriptions and prices — as extra rows. Use the built-in **geo-grid** to sweep many points across a city and de-duplicate the results automatically, so you get broad, clean coverage in a single run.

### What data can you get?

**Per restaurant:**

| Field | Description |
| --- | --- |
| `id` | Restaurant identifier. |
| `code` | Short restaurant code. |
| `name` | Restaurant name. |
| `cuisines` | List of cuisine tags (e.g. Pizza, Sushi, Burgers). |
| `rating` | Average customer rating. |
| `reviewCount` | Number of ratings. |
| `address` | Street address. |
| `latitude` | Restaurant latitude. |
| `longitude` | Restaurant longitude. |
| `minOrder` | Minimum order amount. |
| `deliveryFee` | Delivery fee. |
| `isOpen` | Whether the restaurant is currently accepting delivery. |
| `url` | Link to the restaurant page. |

**Per menu item** (when **Include menu items** is on):

| Field | Description |
| --- | --- |
| `vendorId` | Restaurant the item belongs to. |
| `vendorName` | Restaurant name. |
| `category` | Menu section (e.g. Pizza, Drinks). |
| `itemName` | Dish name. |
| `price` | Item price. |
| `description` | Dish description, when available. |

### Use cases

- **Food-market research** — map the restaurants, cuisines and price points in any city.
- **Price & competitor monitoring** — track delivery fees, minimum orders and menu prices over time.
- **Lead generation** — build lists of restaurants with addresses and coordinates for sales outreach.
- **Menu & pricing analysis** — compare dishes and prices across restaurants and neighbourhoods.
- **Dashboards & maps** — power location, coverage and demand dashboards from clean coordinates.
- **Automation** — feed fresh restaurant and menu data into your own pipelines on a schedule.

### How to use it

1. Add **Foodora Scraper** to your Apify account and open its input.
2. Enter a **City** (e.g. Stockholm), or set **Latitude** + **Longitude** for an exact point.
3. Optionally turn on **Include menu items** to also collect every dish and price.
4. Optionally set **Grid radius (km)** and **Grid step (km)** to sweep a whole city.
5. Set **Max restaurants** to cap the output if you like, then click **Run**.
6. Export the results as JSON, CSV, Excel or XML.

### Input

```json
{
  "city": "Stockholm",
  "includeMenu": true,
  "maxItems": 50
}
```

| Field | Description |
| --- | --- |
| `city` | City to scrape; mapped to a centre coordinate and country. |
| `latitude` / `longitude` | Exact point to search around (overrides `city`). |
| `country` | Two-letter country code (auto-filled from a supported city). |
| `includeMenu` | Also collect each restaurant's menu items and prices. |
| `gridRadiusKm` | Half-width of a square geo-grid, in km, to cover a whole city. `0` = single point. |
| `gridStep` | Spacing in km between grid points. |
| `maxItems` | Cap the number of restaurants. `0` = no limit. |

### What you get

One flat JSON row per restaurant, plus one row per menu item when menus are included — ready to export to CSV, Excel, JSON or XML.

```json
{
  "id": "37697",
  "code": "rlxo",
  "name": "Taco Bell Vasagatan",
  "cuisines": ["Mexican", "Burritos", "Tacos"],
  "rating": 3.7,
  "reviewCount": 585,
  "address": "Vasagatan 14",
  "latitude": 59.331,
  "longitude": 18.058,
  "minOrder": 120,
  "deliveryFee": 59,
  "isOpen": true,
  "url": "https://foodora.se/restaurant/rlxo/taco-bell-vasagatan"
}
```

```json
{
  "vendorId": "37697",
  "vendorName": "Taco Bell Vasagatan",
  "category": "Tacos",
  "itemName": "Crunchy Taco Supreme",
  "price": 39,
  "description": "Crispy taco shell with seasoned beef, cheese and fresh tomato"
}
```

### FAQ

**Which cities and countries are supported?**
Use a supported city name for one-click setup — Stockholm, Gothenburg, Malmö, Vienna, Graz, Oslo, Bergen, Prague, Brno, Budapest, Debrecen — covering Sweden, Austria, Norway, Czechia and Hungary. For anywhere else Foodora serves, set your own Latitude and Longitude together with the two-letter country code.

**How do I cover a whole city?**
Set **Grid radius (km)** to sweep a square of points around the centre, and **Grid step (km)** to control how dense the sweep is. Results are de-duplicated across all points automatically.

**How do I get menu prices?**
Turn on **Include menu items**. Each restaurant then adds extra rows, one per dish, with its category, name, price and description.

**How many restaurants can I get?**
As many as deliver to the area. Use **Max restaurants** to cap the run, or leave it at `0` for everything found.

**What export formats are available?**
JSON, CSV, Excel and XML, plus programmatic access through the Apify API.

**Can I use this with n8n?**
Yes. Run it from the [Apify n8n community node](https://apify.com/integrations/n8n) or trigger it over HTTP, then pass the dataset items straight into your n8n workflow to enrich records, monitor prices or drive downstream steps.

**Can I connect this to my other tools?**
It works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Airbyte](https://docs.apify.com/platform/integrations/airbyte), [GitHub](https://docs.apify.com/platform/integrations/github), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**How fresh is the data?**
Every run collects live listings and menus at run time. Re-run on a schedule to keep your copy current.

### Related Actors

- [Google Maps Scraper](https://apify.com/hipersoft/google-maps-scraper) — businesses, ratings, reviews and contacts from Google Maps.
- [Amazon Product Scraper](https://apify.com/hipersoft/amazon-product-scraper) — product details, prices and ratings in bulk.
- [Google Maps Reviews](https://apify.com/hipersoft/google-maps-reviews) — pull reviews for any place at scale.

### Notes

Original clean-room implementation. Collects only publicly available restaurant and menu information; you are responsible for compliant use. All trademarks, including Foodora, belong to their respective owners and this actor is not affiliated with or endorsed by them.

# Actor input Schema

## `city` (type: `string`):

A city to scrape. The city is mapped to a default centre coordinate and country. Supported: Stockholm, Gothenburg, Malmo, Vienna, Graz, Oslo, Bergen, Prague, Brno, Budapest, Debrecen. For any other location, use Latitude + Longitude instead. Ignored if Latitude and Longitude are set.

## `latitude` (type: `string`):

Latitude of the point to search around, e.g. "59.3293". Use together with Longitude to target an exact location. Overrides City when both are set.

## `longitude` (type: `string`):

Longitude of the point to search around, e.g. "18.0686". Use together with Latitude to target an exact location. Overrides City when both are set.

## `country` (type: `string`):

Two-letter Foodora country code for the location: se (Sweden), at (Austria), no (Norway), cz (Czechia), hu (Hungary). Auto-filled from City when a supported city is used; set it explicitly when scraping by Latitude/Longitude. Defaults to se.

## `includeMenu` (type: `boolean`):

When enabled, also fetch each restaurant's full menu and emit one extra row per menu item (category, item name, price and description). This adds one request per restaurant, so it is slower. Leave off to collect restaurants only.

## `gridRadiusKm` (type: `integer`):

Optional. To cover a whole city, sweep a square grid of points instead of a single point. This is the half-width of that square in kilometres around the centre. 0 = single point (fastest). Larger radius = more coverage but more requests. Results are de-duplicated across points.

## `gridStep` (type: `integer`):

Optional. Spacing in kilometres between grid points when Grid radius is set. Smaller step = denser coverage and more requests. Defaults to the grid radius (a 3x3 sweep) when left at 0.

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

Maximum number of restaurants to collect. 0 = no limit (collect everything found). Menu item rows do not count towards this limit.

## Actor input object example

```json
{
  "city": "Stockholm",
  "latitude": "59.3293",
  "longitude": "18.0686",
  "country": "se",
  "includeMenu": false,
  "gridRadiusKm": 0,
  "gridStep": 0,
  "maxItems": 0
}
```

# Actor output Schema

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

The results as dataset items.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/foodora-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/foodora-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call hipersoft/foodora-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/foodora-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/Q86EETsVtB2cYWT0L/builds/JNVWJoS4Ljyket8sP/openapi.json