# Yemeksepeti Scraper: Restaurants, Menus and Prices (`dodoflix/yemeksepeti-scraper`) Actor

Scrape Yemeksepeti restaurants and menus by location: rating, cuisines, delivery fee, minimum order, delivery time and menu prices in TRY. Fast HTTP scraper, no browser.

- **URL**: https://apify.com/dodoflix/yemeksepeti-scraper.md
- **Developed by:** [Doğukan Metan](https://apify.com/dodoflix) (community)
- **Categories:** Other
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Yemeksepeti Scraper

Get restaurants and full menus from [Yemeksepeti](https://www.yemeksepeti.com) for any delivery location in Turkey as clean JSON, CSV or Excel: rating, cuisines, delivery fee, minimum order, delivery time, open status, coordinates and every menu item with its price in TRY. Runs on plain HTTP, so it is fast and cheap. The price already includes platform usage.

### What you can do with it

- **Map a neighborhood.** List every restaurant that delivers to a district or an exact point, nearest first, with rating, review count, cuisines and price level.
- **Track menu prices.** Pull the whole menu of the restaurants you care about on a schedule and watch prices, discounts and sold-out items change.
- **Compare competitors.** Filter by cuisine (burger, doner, pizza, kofte) and compare minimum orders, delivery times and ratings across an area.
- **Build lead and market lists.** Restaurant names, addresses, coordinates and URLs for sales, site selection and market research.

### Quick start

Open the Input tab, keep the prefilled `Kadıköy` and press Start. Or pick one of these:

**Restaurants delivering to Kadıköy**

```json
{
    "locations": ["Kadıköy"],
    "maxRestaurantsPerLocation": 100
}
```

**Only burger and doner places, with menus**

```json
{
    "locations": ["Beşiktaş"],
    "cuisines": ["Burger", "Döner"],
    "includeMenu": true,
    "maxRestaurantsPerLocation": 10
}
```

**One restaurant and its menu**

```json
{
    "restaurantUrls": [{ "url": "https://www.yemeksepeti.com/restaurant/fkdc/chef-bons-burger-fkdc" }],
    "includeMenu": true
}
```

**An exact address point**

```json
{
    "locations": ["40.9903,29.0290"],
    "maxRestaurantsPerLocation": 50
}
```

### Input

| Field | What it does |
|---|---|
| `locations` | Turkish provinces (`Ankara`), districts of Istanbul, Ankara, Izmir, Antalya and Bursa (`Kadıköy`, `Çankaya`), or coordinates as `latitude,longitude`. You get the restaurants that deliver to that point |
| `restaurantUrls` | Restaurant page URLs. Returns the restaurant, and its menu with `includeMenu` |
| `cuisines` | Only these cuisines. Names, slugs and ids all work (`Döner`, `doner`, `Burger`) |
| `includeDetails` | On by default. One extra request per restaurant for delivery fee, minimum order, delivery time range and open status. Off is faster but has no delivery fee |
| `includeMenu` | One row per menu item. Every menu item counts as a result |
| `maxItems` | Stop the whole run after this many results, restaurants and menu items together |
| `maxRestaurantsPerLocation` | Restaurants per location, nearest first. 100 by default |
| `maxConcurrency`, `maxRequestsPerMinute` | Speed limits, 3 and 120 by default |
| `proxyConfiguration` | No proxy by default. Switch on Apify Proxy (Turkey residential) if runs fail with 403 |

### Output

Every result has a `type`: `restaurant` or `menuItem`. Download the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API.

**Restaurant**

```json
{
    "type": "restaurant",
    "code": "fkdc",
    "id": 420578,
    "name": "Chef Bon's Burger",
    "url": "https://www.yemeksepeti.com/restaurant/fkdc/chef-bons-burger-fkdc",
    "cuisines": ["Burger"],
    "primaryCuisine": "Burger",
    "rating": 5,
    "reviewCount": 6,
    "priceLevel": 2,
    "deliveryFee": 0,
    "deliveryFeeOriginal": 0,
    "minOrder": 300,
    "deliveryTimeMin": 20,
    "deliveryTimeMax": 35,
    "address": "Kuşdili Caddesi 56",
    "city": "Istanbul",
    "latitude": 40.98831,
    "longitude": 29.03341,
    "distanceKm": 0.431,
    "status": "OPEN",
    "isOpen": true,
    "isNew": false,
    "image": "https://yemeksepeti.dhmedia.io/image/fd-tr/LH/fkdc-listing.jpg",
    "searchLocation": "Kadıköy, İstanbul"
}
```

**Menu item**

```json
{
    "type": "menuItem",
    "restaurantCode": "fkdc",
    "restaurantId": 420578,
    "restaurantName": "Chef Bon's Burger",
    "restaurantUrl": "https://www.yemeksepeti.com/restaurant/fkdc/chef-bons-burger-fkdc",
    "category": "Burgerler",
    "itemId": "82881598",
    "name": "Klasik Çıtır Burger",
    "description": "Tavuk burger köftesi, ranch sos, turşu, marul, cheddar peyniri",
    "price": 395,
    "discountedPrice": null,
    "priceFrom": false,
    "variationCount": 1,
    "image": "https://yemeksepeti.dhmedia.io/image/fd-tr/Products/82881598.jpg",
    "isSoldOut": false,
    "isCustomizable": false,
    "isAlcoholic": false,
    "searchLocation": "Kadıköy, İstanbul"
}
```

Prices and fees are numbers in TRY. `priceFrom` is true when the price is a starting price before options are chosen. `deliveryTimeMin` and `deliveryTimeMax` are the site's estimate in minutes. Values the site does not give are `null`, never guessed. `id` is `null` for restaurants requested by URL.

### Good to know

- Delivery fee, minimum order, time and open status depend on the delivery point. They are what an anonymous visitor sees at that point. The site reports a delivery fee of 0 for most restaurants, and campaigns or prices for signed-in customers are not visible, so check a fee in the app before relying on it.
- A restaurant that is out of reach of the location has no fee or minimum order (`status` shows `OUT_OF_REACH`).
- A restaurant URL given without a location is queried at the restaurant's own address, so `distanceKm` is close to 0.
- `isOpen` and `status` are the site's state at run time. Restaurants that are closed when you run are listed only if the site lists them.
- Locations use a built-in list of province and district centers. For any other place, pass coordinates.

### Pricing

You pay per result: **$1.00 per 1,000 results**, and less on higher Apify plans. Platform usage is included, so there are no extra charges. A restaurant is one result and every menu item is one result. For example, 100 restaurants with menus of about 60 items each cost about $6. You only pay for results you get, and a run that finds nothing costs almost nothing.

You can cap spending on every run in the run options. The Actor stops cleanly when the cap is reached.

### FAQ

**Do I need a proxy?** The data endpoints it calls answer plain requests, so no proxy is set by default. If your runs fail with 403 errors, switch on Apify Proxy and pick the Turkey residential group.

**How many restaurants can I get?** Everything that delivers to the point. A central Istanbul district lists 1,000 to 1,700 restaurants. Raise `maxRestaurantsPerLocation`.

**How do I cover a whole city?** Add several districts or coordinates to `locations`. Restaurants found twice are returned once.

**How fast is it?** About 100 restaurants per minute with delivery details at the default speed, and each restaurant's whole menu comes in the same request. The site accepted over twice that speed in tests without errors, but the default stays well below it.

**Can it scrape private or logged-in content?** No. Only what any visitor can see without signing in.

**Why did I get fewer results than I set?** The location has fewer restaurants, the cuisine filter matched fewer, or `maxItems` ended the run first.

**Can I use it from code?**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('dodoflix/yemeksepeti-scraper').call({
    locations: ['Kadıköy'],
    maxRestaurantsPerLocation: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

It also connects to Make, Zapier, Google Sheets, Slack and webhooks from the Integrations tab.

**Something broke or a field is missing.** Open an issue on the Issues tab with the input you used.

### Legal

This Actor collects public restaurant and menu data. You are responsible for how you use the data, including KVKK/GDPR and the site's terms and robots.txt.

### Türkçe özet

Yemeksepeti restoranlarını ve menülerini konuma göre JSON, CSV veya Excel olarak indirin: puan, mutfak, teslimat ücreti, minimum sepet, teslimat süresi ve TRY menü fiyatları.

# Actor input Schema

## `locations` (type: `array`):

Places to list restaurants for: a Turkish province (Istanbul, Ankara, Izmir), an Istanbul, Ankara, Izmir, Antalya or Bursa district (Kadikoy, Besiktas, Cankaya), or exact coordinates as "latitude,longitude" (41.0082,28.9784). Restaurants are the ones that deliver to that point.

## `restaurantUrls` (type: `array`):

Restaurant pages such as https://www.yemeksepeti.com/restaurant/bzid/muaf-mutfak. Returns the restaurant, plus its menu when Include menu is on. Without a location the restaurant is queried at its own address.

## `cuisines` (type: `array`):

Only restaurants with one of these cuisines, for example Burger, Doner, Pizza, Kofte. Names, slugs and ids all work. Applies to locations only.

## `includeDetails` (type: `boolean`):

Fetch each restaurant's page data for delivery fee, minimum order, delivery time range and open status at the location. One extra request per restaurant. Off returns the list data only: faster, but no delivery fee and an approximate delivery time.

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

Also output one row per menu item (category, name, description, price in TRY). Uses the same request as delivery details. Every menu item counts as a result.

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

Stop the whole run after this many results, restaurants and menu items together. Leave empty for no limit.

## `maxRestaurantsPerLocation` (type: `integer`):

Restaurants to collect for each location, nearest first. A busy Istanbul district has 1,000 or more.

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

Requests in flight at once. Raise it only if you see no errors in the log.

## `maxRequestsPerMinute` (type: `integer`):

Request speed limit. The default is well under what the site accepted in tests.

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

No proxy is needed for the data endpoints this Actor calls. If runs fail with 403 errors, switch on Apify Proxy with the Turkey residential group.

## Actor input object example

```json
{
  "locations": [
    "Kadıköy"
  ],
  "includeDetails": true,
  "includeMenu": false,
  "maxRestaurantsPerLocation": 20,
  "maxConcurrency": 3,
  "maxRequestsPerMinute": 120,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "locations": [
        "Kadıköy"
    ],
    "maxRestaurantsPerLocation": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("dodoflix/yemeksepeti-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 = {
    "locations": ["Kadıköy"],
    "maxRestaurantsPerLocation": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("dodoflix/yemeksepeti-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 '{
  "locations": [
    "Kadıköy"
  ],
  "maxRestaurantsPerLocation": 20
}' |
apify call dodoflix/yemeksepeti-scraper --silent --output-dataset

```

## MCP server setup

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