# Rappi Restaurant Scraper (`crawlerbros/rappi-scraper`) Actor

Scrape Rappi restaurant listings across Latin America. Get name, cuisine, address, rating, delivery fee and ETA by city, with cuisine and keyword search filters. Mexico, Peru, Argentina, Chile, Uruguay, Ecuador.

- **URL**: https://apify.com/crawlerbros/rappi-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Rappi Restaurant Scraper

Scrape restaurant listings from [Rappi](https://www.rappi.com) — the Latin American on-demand delivery platform. Get restaurant names, cuisines, street addresses, ratings, delivery fees, and estimated delivery times across Mexico, Peru, Argentina, Chile, Uruguay, and Ecuador. No login, no cookies, no residential proxy required.

### What this actor does

- **Two modes:** browse every restaurant Rappi shows for a city, or search restaurants/cuisines by keyword
- **6 countries** — Mexico (Ciudad de Mexico), Peru (Lima), Argentina (Buenos Aires), Chile (Santiago), Uruguay (Montevideo), Ecuador (Quito)
- **Filters:** cuisine, minimum rating, "currently open only", "has active promotion only"
- **Real addresses** — optionally visits each restaurant's page to collect its exact street address
- **Empty fields are omitted** — every record only contains data Rappi actually returned

### Output per restaurant

- `restaurantId` — Rappi's internal store ID
- `name` — restaurant name (includes branch/location when available)
- `cuisine[]` — cuisine categories (in the local language of the city)
- `city`, `country`
- `address` — full street address (when `fetchDetails` is enabled)
- `rating` — star rating (0-5)
- `reviewCount`
- `deliveryFee`, `currency`
- `estimatedDeliveryTime` — e.g. `31 min`
- `imageUrl` — restaurant photo
- `restaurantUrl` — direct link to the restaurant's Rappi page
- `isOpen` — currently accepting orders
- `promotionText` — active promotion badge, e.g. `Envío Gratis: Aplican TyC`, `Hasta 57% Off` (omitted when there's no active promotion)
- `isPrimeExclusive` — restaurant is exclusive to Rappi Prime members
- `hasFreeShipping` — free delivery is currently offered
- `isNew` — recently added to Rappi
- `latitude`, `longitude` — GPS coordinates (when `fetchDetails` is enabled)
- `todayHours` — today's opening hours, e.g. `08:00:00 - 23:30:00` (when `fetchDetails` is enabled)
- `isOpenToday` — restaurant has scheduled hours today (when `fetchDetails` is enabled)
- `brandName` — parent brand/chain name (when `fetchDetails` is enabled)
- `storeType` — store classification, e.g. `restaurant` (when `fetchDetails` is enabled)
- `ratingBreakdown` — count of reviews per 1-5 star bucket, e.g. `{"1": 15, "2": 1, "3": 8, "4": 6, "5": 30}` (when `fetchDetails` is enabled)
- `sourceUrl`, `scrapedAt`, `recordType: "restaurant"`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `restaurants` | `restaurants` (browse) or `search` (keyword) |
| `city` | string | `ciudad-de-mexico` | One of 6 supported cities |
| `query` | string | – | Required for `search`; matched against name + cuisine |
| `cuisine` | string | – | Filter by cuisine, e.g. `Pizza`, `Sushi`, `Mexicana` |
| `minRating` | integer | – | Drop restaurants below this rating (0-5) |
| `onlyOpen` | boolean | `false` | Only currently-open restaurants |
| `onlyWithPromotion` | boolean | `false` | Only restaurants with an active promotion |
| `fetchDetails` | boolean | `true` | Also fetch each restaurant's address, GPS coordinates, and today's hours (1 extra request/restaurant) |
| `maxItems` | integer | `15` | Hard cap (1-30) |
| `proxyConfiguration` | object | off | Optional Apify proxy (AUTO datacenter group) |

#### Example: browse Mexico City restaurants with addresses

```json
{
  "mode": "restaurants",
  "city": "ciudad-de-mexico",
  "cuisine": "Mexicana",
  "fetchDetails": true,
  "maxItems": 20
}
````

#### Example: keyword search for burger places in Lima, fast (no address lookups)

```json
{
  "mode": "search",
  "city": "lima",
  "query": "hamburguesa",
  "fetchDetails": false
}
```

#### Example: only open, well-rated restaurants in Buenos Aires

```json
{
  "mode": "restaurants",
  "city": "buenos-aires",
  "minRating": 3,
  "onlyOpen": true
}
```

### Use cases

- **Market research** — compare cuisine mix, ratings, and delivery fees across LatAm cities
- **Competitor tracking** — monitor a chain's presence, address footprint, and ratings across markets
- **Delivery cost analysis** — compare delivery fees and ETAs city to city
- **Local business directories** — seed a directory with real restaurant listings and addresses
- **Business intelligence** — see which restaurants are open and how they rank

### FAQ

**Which cities are supported?** Ciudad de Mexico (Mexico), Lima (Peru), Buenos Aires (Argentina), Santiago (Chile), Montevideo (Uruguay), Quito (Ecuador).

**How many restaurants can I get per run?** Up to 30 — the number Rappi's city catalog page returns.

**Why is `cuisine` a free-text field instead of a dropdown?** Rappi shows cuisine names in Spanish and the exact set differs by city (e.g. `Poke` and `Sushi` are common in Mexico City, while a smaller city may only list a handful). Type any cuisine you see in the results, or leave it blank to get every cuisine.

**What does `address` require?** Turn on `fetchDetails` (on by default) — the actor visits each restaurant's page to read its street address. Turning it off skips this extra request per restaurant for a faster run.

**Do I need a proxy?** No. Rappi's public listing pages work from Apify's standard datacenter IPs. The proxy option is available for extra reliability if you run into rate limiting.

**Is login required?** No — all data comes from Rappi's public restaurant listing and detail pages.

# Actor input Schema

## `mode` (type: `string`):

`Browse restaurants` lists the restaurants Rappi shows for the selected city (optionally filtered by cuisine). `Search` additionally filters those restaurants by a keyword matched against the restaurant name and cuisine.

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

City to scrape Rappi restaurants for.

## `query` (type: `string`):

Required when mode=search. Matched (case-insensitive) against restaurant name and cuisine, e.g. `pizza`, `sushi`, `mcdonald`.

## `cuisine` (type: `string`):

Optional. Filter restaurants by cuisine (case-insensitive substring match), e.g. `Pizza`, `Sushi`, `Mexicana`, `Hamburguesas`. Cuisine names are shown in the local language (Spanish) of the selected city.

## `minRating` (type: `integer`):

Drop restaurants with a star rating (0-5) below this value.

## `onlyOpen` (type: `boolean`):

Only return restaurants that are currently open for delivery.

## `onlyWithPromotion` (type: `boolean`):

Only return restaurants that currently show an active promotion (e.g. free shipping, percentage off).

## `fetchDetails` (type: `boolean`):

Visit each restaurant's page to also collect its street address, precise review count, GPS coordinates, today's opening hours, and whether it's open today. Adds one extra request per restaurant. Turn off for a faster run without these fields.

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

Hard cap on emitted records. Rappi shows up to 30 restaurants per city catalog page.

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

Optional. Rappi does not require a proxy from most locations, but you can enable Apify's free datacenter proxy (AUTO group) for extra reliability.

## Actor input object example

```json
{
  "mode": "restaurants",
  "city": "ciudad-de-mexico",
  "query": "pizza",
  "onlyOpen": false,
  "onlyWithPromotion": false,
  "fetchDetails": true,
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Dataset containing all scraped Rappi restaurants.

# 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 = {
    "mode": "restaurants",
    "city": "ciudad-de-mexico",
    "query": "pizza",
    "onlyOpen": false,
    "onlyWithPromotion": false,
    "fetchDetails": true,
    "maxItems": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rappi-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 = {
    "mode": "restaurants",
    "city": "ciudad-de-mexico",
    "query": "pizza",
    "onlyOpen": False,
    "onlyWithPromotion": False,
    "fetchDetails": True,
    "maxItems": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rappi-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 '{
  "mode": "restaurants",
  "city": "ciudad-de-mexico",
  "query": "pizza",
  "onlyOpen": false,
  "onlyWithPromotion": false,
  "fetchDetails": true,
  "maxItems": 15
}' |
apify call crawlerbros/rappi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rappi Restaurant Scraper",
        "description": "Scrape Rappi restaurant listings across Latin America. Get name, cuisine, address, rating, delivery fee and ETA by city, with cuisine and keyword search filters. Mexico, Peru, Argentina, Chile, Uruguay, Ecuador.",
        "version": "1.0",
        "x-build-id": "5fol4OOIocfxhahr1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rappi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rappi-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/crawlerbros~rappi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rappi-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/crawlerbros~rappi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rappi-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",
                "required": [
                    "mode",
                    "city"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "restaurants",
                            "search"
                        ],
                        "type": "string",
                        "description": "`Browse restaurants` lists the restaurants Rappi shows for the selected city (optionally filtered by cuisine). `Search` additionally filters those restaurants by a keyword matched against the restaurant name and cuisine.",
                        "default": "restaurants"
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "ciudad-de-mexico",
                            "lima",
                            "buenos-aires",
                            "santiago",
                            "montevideo",
                            "quito"
                        ],
                        "type": "string",
                        "description": "City to scrape Rappi restaurants for.",
                        "default": "ciudad-de-mexico"
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Required when mode=search. Matched (case-insensitive) against restaurant name and cuisine, e.g. `pizza`, `sushi`, `mcdonald`."
                    },
                    "cuisine": {
                        "title": "Cuisine filter",
                        "type": "string",
                        "description": "Optional. Filter restaurants by cuisine (case-insensitive substring match), e.g. `Pizza`, `Sushi`, `Mexicana`, `Hamburguesas`. Cuisine names are shown in the local language (Spanish) of the selected city."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop restaurants with a star rating (0-5) below this value."
                    },
                    "onlyOpen": {
                        "title": "Only currently open",
                        "type": "boolean",
                        "description": "Only return restaurants that are currently open for delivery.",
                        "default": false
                    },
                    "onlyWithPromotion": {
                        "title": "Only with active promotion",
                        "type": "boolean",
                        "description": "Only return restaurants that currently show an active promotion (e.g. free shipping, percentage off).",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch restaurant address",
                        "type": "boolean",
                        "description": "Visit each restaurant's page to also collect its street address, precise review count, GPS coordinates, today's opening hours, and whether it's open today. Adds one extra request per restaurant. Turn off for a faster run without these fields.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Rappi shows up to 30 restaurants per city catalog page.",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Rappi does not require a proxy from most locations, but you can enable Apify's free datacenter proxy (AUTO group) for extra reliability.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
