# Rappi Restaurants & Stores Scraper (`parseforge/rappi-scraper`) Actor

Scrapes restaurant and store listings from Rappi across 9 Latin American countries. Returns each listing as a flat row with name, rating, delivery details, and metadata. Filter by store type, Prime status, or free delivery.

- **URL**: https://apify.com/parseforge/rappi-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Agents, Automation
- **Stats:** 58 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Rappi Restaurants & Stores Scraper

**Scrape restaurants, menus, and stores from Rappi across 9 Latin American countries.** Collect names, ratings, delivery fees, and store details from any category. Export to CSV, JSON, Excel, or XML.

Rappi's app is built for ordering, not for bulk data collection. Manually copying restaurant details, menus, or store listings across multiple countries is slow and error-prone. This actor reads the public store feeds directly, letting you pull structured data from Colombia, Mexico, Brazil, and six other markets in one run. Filter by store type, Prime status, or free delivery, and get every result in a consistent, flat schema.

| Who uses it | What they scrape Rappi for |
|---|---|
| Market researchers | Tracking which restaurant chains are expanding into new Latin American cities. |
| Competitive intelligence analysts | Monitoring competitor menus, pricing, and delivery fees across markets. |
| Food industry consultants | Building a database of delivery-only kitchens and virtual brands on Rappi. |
| Data journalists | Investigating delivery fee patterns and restaurant density by neighborhood. |

### What it does

This Actor collects restaurant and store listings from Rappi by direct URL or country and category filters, and returns each one as a flat row with its name, rating, delivery details, and metadata.

- 🌎 **Multi-country support:** scrape from Colombia, Mexico, Brazil, Peru, Chile, Argentina, Ecuador, Uruguay, and Costa Rica.
- 🏪 **Store type filtering:** choose from Restaurants, Market, Pharmacies, or Liquor Stores.
- ⭐ **Sort by rating:** pull the highest-rated restaurants first to focus on top performers.
- 🚀 **Prime filter:** isolate Rappi Prime exclusive restaurants for premium market analysis.
- 🚚 **Free delivery filter:** find restaurants offering free delivery to study promotional strategies.
- 🔗 **Direct URL input:** scrape specific store pages or category URLs you already know.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Rappi data

**📊 Monitor restaurant expansion.**

A market researcher scrapes all restaurants in Bogotá and São Paulo monthly to track which international chains are entering new Latin American markets.

**💰 Compare delivery fees.**

A competitive analyst pulls restaurant listings filtered by free delivery across Mexico and Colombia to benchmark competitor delivery strategies.

**🏪 Catalog virtual brands.**

A food industry consultant scrapes all restaurants in a city to identify delivery-only kitchens and ghost kitchens operating on Rappi.

**📈 Track ratings over time.**

A data journalist scrapes the same set of restaurant URLs weekly, sorting by rating, to report on quality trends in the delivery market.

### Why choose this scraper

|  | What you get |
|---|---|
| **Consistent schema** | Every restaurant or store comes out in the same flat format, ready for analysis. |
| **No API key needed** | Reads the public Rappi feeds directly with no registration or OAuth. |
| **Multi-country in one run** | Switch countries with a dropdown, no separate actors or configurations needed. |
| **Flexible input** | Use search filters for discovery or direct URLs for targeted scraping. |

### How it compares

This actor covers more countries and store types than the alternatives, with flexible input methods for both discovery and targeted scraping.

| Feature | ParseForge | Rappi Restaurant Scraper | Rappi Restaurants Scraper - Cheap |
|---|---|---|---|
| Countries supported | 9 (CO, MX, BR, PE, CL, AR, EC, UY, CR) | 6 (BR, CO, AR, CL, PE, UY) | Not listed |
| Store types beyond restaurants | Yes (Market, Pharmacies, Liquor) | Not listed | Not listed |
| Direct URL input | Yes | Not listed | Not listed |
| Prime restaurant filter | Yes | Not listed | Not listed |
| Free delivery filter | Yes | Not listed | Not listed |
| Sort by rating | Yes | Not listed | Not listed |

### Configure the run

Drive the Actor from direct Rappi URLs or by selecting a country and store type, and filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.5 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $50.00 |
| 1,000 results | $500.00 |
| 10,000 results | $5000.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Rappi Restaurants & Stores Scraper](https://apify.com/parseforge/rappi-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Rappi through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/rappi-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that you are not using both startUrls and search filters at the same time. These input methods are mutually exclusive. Pick one and clear the other.

**Why does the actor stop before reaching maxItems?**

The actor stops when it has exhausted the available listings for your chosen country and store type. Try a different category or country if you need more data.

**Why are some restaurant fields empty?**

Rappi does not always populate every field for every listing. Missing data in the output reflects what Rappi published for that particular store.

**Why can't I find a specific restaurant?**

The restaurant may not be listed in the default sort order. Try sorting by rating or using a direct URL if you know the restaurant's page.

**Why does the actor fail when I use both input methods?**

The startUrls and search filter sections are mutually exclusive. Remove all values from one section before running.

### FAQ

| Question | Answer |
|---|---|
| Which countries does this actor support? | It supports nine countries: Colombia, Mexico, Brazil, Peru, Chile, Argentina, Ecuador, Uruguay, and Costa Rica. Select the country code from the dropdown in the input. |
| Can I scrape a specific restaurant's menu? | Yes. Paste the direct URL of any Rappi restaurant or store page into the startUrls field, and the actor will collect its available data. |
| What is the difference between startUrls and search filters? | They are mutually exclusive input methods. Use startUrls to scrape specific pages you already know. Use search filters to discover and collect listings by country and category. |
| Does this actor get menu item prices? | The actor collects the data Rappi exposes on its public store and restaurant listing pages. The exact fields returned are shown in the sample output below. |
| How many products can I scrape in one run? | You can set the maxItems limit up to 1,000,000. The actor will stop once it reaches that count or exhausts the available listings. |
| Can I filter by delivery time? | The input schema includes filters for Prime status and free delivery. Other filters like delivery time are not available as input parameters. |
| What store types can I scrape? | You can choose from Restaurants, Market, Pharmacies, and Liquor Stores using the storeType dropdown. |
| Does this actor require a Rappi login? | No. It reads the publicly accessible store feeds and does not need a Rappi account, API key, or login. |
| How do I paginate through results? | Use the storeOffset parameter to skip ahead in the listings. The actor increments in steps of 50. |
| Can I scrape multiple countries in one run? | Each run targets one country when using search filters. To scrape multiple countries, run the actor once per country or use direct URLs from different countries in startUrls. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Rappi, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many products to collect per run.

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

Direct URLs to scrape from Rappi. Use this OR filter parameters below, not both. Examples: https://www.rappi.com.co/restaurantes, https://www.rappi.com.co/tiendas/restaurantes, https://www.rappi.com.co/tiendas/market

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

Country code to scrape from. Use this OR startUrls above, not both.

## `restaurantSort` (type: `string`):

Sort restaurants by rating or use default order

## `restaurantPrime` (type: `boolean`):

Filter to show only Prime exclusive restaurants

## `restaurantFreeDelivery` (type: `boolean`):

Filter to show only restaurants with free delivery

## `storeType` (type: `string`):

Type of store to scrape

## `storeOffset` (type: `integer`):

Pagination offset for store listings (0, 50, 100, etc.)

## Actor input object example

```json
{
  "maxItems": 10,
  "country": "co",
  "restaurantSort": "default",
  "restaurantPrime": false,
  "restaurantFreeDelivery": false,
  "storeType": "restaurantes",
  "storeOffset": 0
}
```

# Actor output Schema

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

Complete dataset with all scraped items (restaurants and stores)

## `overview` (type: `string`):

Overview view with key fields displayed in a table format

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rappi-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 '{
  "maxItems": 10
}' |
apify call parseforge/rappi-scraper --silent --output-dataset

```

## MCP server setup

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