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

Yemeksepeti restaurants by city or coordinates: rating, review count, delivery fee, minimum order, offers, opening hours. Menus mode adds one row per item size with TRY price, pre-discount price and options. No login. $1.50 per 1,000 restaurants, full menus +$1.00 per 1,000.

- **URL**: https://apify.com/subimpact/yemeksepeti-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 restaurants

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: Restaurants, Menus & Prices

Yemeksepeti restoran listesi, menü ve fiyat verisi (Türkiye). Restaurants by city or
coordinates, and full menus with one row per orderable size, prices in TRY.

This Actor collects public Yemeksepeti data over plain HTTP. No browser, no login, no API key.
One run can return restaurants from a city (rating, review counts, delivery fee, minimum
order, offers, opening hours, coordinates) and, in menus mode, every item on their menus with
its price, pre-discount price and discount percentage.

### What you get

Every dataset item has a `rowType`, so one dataset holds both kinds of row:

- `restaurant`: one row per restaurant. Code, id, name and URL, cuisines, rating, review
  counts, price level, address, city, coordinates, distance from your search point,
  minimum order, delivery fee, delivery time, open/active flags, chain, offer names,
  opening hours, logo, website, currency, search location and scrape time.
- `menuItem` (menus mode): one row per orderable size. Product, description, menu, category,
  size name, price, price before discount, discount percent, container price, sold out,
  alcoholic, vegetarian, popular flag, image URL and, with `includeOptions`, the option
  groups of that item with option prices.
- `error` / `info`: a note about an input that could not be used (unknown restaurant code, a
  typo in a code list, an empty area). These rows are never charged.

Prices are in Turkish lira (`currency: "TRY"`), exactly as the platform publishes them at
scrape time.

### Input example

This exact input works as written. It reads one restaurant's complete menu, including the
option groups (extras, size choices) with their prices:

```json
{
  "restaurantUrls": ["awhi"],
  "mode": "menus",
  "includeOptions": true
}
```

To discover restaurants instead of naming them, give one or more locations. City presets are
Istanbul, Ankara, Izmir, Antalya and Bursa; a `"lat,lng"` pair works too:

```json
{
  "locations": ["Istanbul"],
  "maxRestaurants": 5,
  "minRating": 4.5
}
```

An empty `{}` input runs the same thing with `locations: ["Istanbul"]` and
`maxRestaurants: 20`. `proxyConfiguration` keeps its default, the Apify residential proxy in
Turkey, which is what the menu requests need; you normally leave it alone.

`restaurantUrls` accepts restaurant URLs
(`https://www.yemeksepeti.com/restaurant/awhi/eyup-sultan-sofrasi-awhi`) or bare codes
(`awhi`). An entry that is neither becomes its own error row and the rest of the list is
still scraped.

### Output examples

Real rows from a recorded run of the input above (field order kept, long arrays shortened):

```json
{
  "rowType": "restaurant",
  "restaurantCode": "awhi",
  "restaurantId": 125626,
  "name": "Eyüp Sultan Sofrası",
  "url": "https://www.yemeksepeti.com/restaurant/awhi/eyup-sultan-sofrasi-awhi",
  "cuisines": ["Kebap & Türk Mutfağı", "Pide & Lahmacun"],
  "rating": 4.5,
  "reviewCount": 9590,
  "reviewWithCommentCount": 0,
  "priceLevel": 2,
  "address": "İmrahor İlyasbey Cd. No:68,  Yedikule mah",
  "city": "Istanbul",
  "latitude": 40.9969589,
  "longitude": 28.928087,
  "distanceKm": null,
  "minimumOrderAmount": 0,
  "deliveryFee": 0,
  "deliveryTimeMinutes": null,
  "isActive": true,
  "isDeliveryEnabled": true,
  "isPickupEnabled": false,
  "isNew": false,
  "isPromoted": false,
  "chainName": null,
  "chainCode": null,
  "offers": ["Tüm ürünlerde %15"],
  "openingHours": [
    { "weekday": 1, "opens": "11:00", "closes": "23:59" },
    { "weekday": 1, "opens": "00:00", "closes": "04:00" }
  ],
  "logoUrl": null,
  "website": null,
  "currency": "TRY",
  "searchLocation": null,
  "scrapedAt": "2026-11-20T03:00:20.377Z"
}
```

```json
{
  "rowType": "menuItem",
  "restaurantCode": "awhi",
  "restaurantName": "Eyüp Sultan Sofrası",
  "menuName": "Ana Menü",
  "categoryName": "Ekonomik Menüler",
  "productId": 73935904,
  "productName": "3'lü Lahmacun Menü",
  "productDescription": "3 Adet Lahmacun + Ezme + Pepsi Max (33 cl.)",
  "variationId": 82616906,
  "variationName": null,
  "price": 552.5,
  "priceBeforeDiscount": 650,
  "discountPercent": 15,
  "containerPrice": null,
  "isSoldOut": false,
  "isAlcoholic": false,
  "isVegetarian": false,
  "isPopular": false,
  "imageUrl": "https://yemeksepeti.dhmedia.io/image/fd-tr/Products/73935904.jpg",
  "optionGroups": null,
  "currency": "TRY",
  "scrapedAt": "2026-11-20T03:00:20.377Z"
}
```

The same restaurant in a `"locations": ["Istanbul"]` run also fills `distanceKm` (for
example `4.403`) and `searchLocation` (`Istanbul`), but `openingHours` stays `null` unless the
restaurant's detail is fetched. A size choice looks like this (`variationName` tells the two
sizes apart; the product has 2 sizes):

```json
{
  "rowType": "menuItem",
  "productName": "Kıymalı Pide",
  "variationId": 44655295,
  "variationName": "1.5 Porsiyon",
  "price": 552.5,
  "priceBeforeDiscount": 650,
  "discountPercent": 15,
  "isPopular": false,
  "currency": "TRY"
}
```

With `includeOptions` an item also carries its option groups, here from a large pizza menu:

```json
{
  "optionGroups": [
    {
      "groupName": "Ekstra Malzeme (Küçük Boy Pizza)",
      "minSelect": 0,
      "maxSelect": 23,
      "options": [
        { "name": "Yeşil Biber", "price": 15, "isSoldOut": false },
        { "name": "Domates", "price": 15, "isSoldOut": false }
      ]
    }
  ]
}
```

### Pricing

Pay per event, no subscription, platform usage included:

- `restaurant`: $1.50 per 1,000 restaurant rows.
- `restaurant-menu`: $1.00 per 1,000 restaurant menus. Charged once per restaurant, after its
  last menu item row, and only when at least one item row was delivered.

Menu item rows themselves are not charged, so a menu with 145 sizes costs the same as a menu
with 10. A full menu for one restaurant, like Eyüp Sultan Sofrası with 105 products and 145
orderable sizes, costs $0.0025 here. The default `{}` run (20 restaurants, restaurants mode)
costs $0.03. Proxy traffic is included in these prices. Error and info rows are never charged.

### How this compares

Free-plan list prices from the Apify Store, checked 2026-11-20:

| Actor | Price | Notes |
|---|---|---|
| This actor | $1.50 / 1,000 restaurants; full menu +$1.00 / 1,000 restaurants | platform usage included, one row per item size |
| hipersoft/yemeksepeti-scraper | $3.00 / 1,000 restaurants (Free tier) | menu items included |
| teodor_banea/yemeksepeti-restaurant-menu-scraper | $2.00 / 1,000 rows + $0.005 per run start | one row per item size |
| dodoflix/yemeksepeti-scraper | $1.00 / 1,000 rows | every menu row is billed |

### How it works and what the limits are

- Restaurants come from Yemeksepeti's public restaurant listing, one request per 50
  restaurants. `maxRestaurants` caps a discovery run across all locations; restaurants are
  taken in the platform's listing order, so a small cap is the cheapest run. When you pass
  codes or URLs, every entry you give is scraped.
- Detail fields (address, opening hours, website, logo, full menu) come from the public
  vendor page data, one request per restaurant. Restaurants mode from a location uses listing
  data only and leaves detail-only fields `null` to keep the run cheap.
- Restaurant detail and menu requests go through the proxy you pick in `proxyConfiguration`.
  The default is the Apify residential proxy in Turkey, which is the tested setting: the menu
  API sits behind a bot check that starts answering HTTP 403 to repeated requests from one
  datacentre IP. Proxy traffic is included in the price, there is no extra charge for it.
- Discovery from a location needs no proxy: the listing endpoint is not behind that bot check,
  so listing requests go out directly. A `{}` run therefore sends no proxied request at all.
- Every restaurant is fetched with its own proxy session. If the bot check answers anyway, the
  request is retried up to 4 more times, each with a new session, after 1, 2, 4 and 8 seconds.
  A restaurant that still fails becomes an uncharged error row and the run continues with the
  next one.
- If the proxy cannot be set up (for example your plan has no residential proxy access) you get
  one uncharged `info` row explaining it, and the detail and menu requests fail with a clear
  message instead of being sent from the Actor's own IP, where the site would block them.
  Turning Apify Proxy off is a quick-test option only: direct menu requests may be blocked.
- `gridRadiusKm` / `gridStepKm` add a square grid of points around each location, which
  surfaces more restaurants in a city. Duplicates are removed by restaurant code and the run
  stops at `maxRestaurants`.
- `searchQuery` matches restaurant names and cuisines, accent and case insensitive (`doner`
  finds `Döner`). `minRating` keeps restaurants at or above a rating. Both filters apply to
  discovery.
- Menus are the delivery menu of the restaurant (language `tr`). An item with several sizes
  produces one row per size, because that is what a customer can order. `isPopular` is true
  when the platform tags the product as popular or puts it in a popular category.
- Menus mode caps item rows per restaurant only if you set `maxMenuItemsPerRestaurant`;
  `0` means the complete menu.
- Every request has a 20 second timeout. Network errors, HTTP 429 and 5xx are retried 3 times
  with backoff. A 404 (unknown restaurant code) is reported as an error row and not retried.
  A block page (HTTP 403 from the site's bot check) is retried with a fresh proxy session, as
  described above.
- An unknown upstream response shape becomes an uncharged error row instead of made-up data.
  If the platform changes its public endpoints, the run reports the problem rather than
  inventing fields.
- The Actor is a plain Node.js program (512 MB is plenty). A local run that delivered 146 rows
  peaked at about 100 MB of memory.
- Yemeksepeti can change its public pages, prices or menus at any time; rows are a snapshot of
  the moment of the run (`scrapedAt`). This Actor is not affiliated with Yemeksepeti or
  Delivery Hero.

Need the reviews too? [Yemeksepeti Reviews Scraper](https://apify.com/subimpact/yemeksepeti-reviews-api)
returns review text, ratings, reviewer info and vendor replies.

### Responsible use

Collect only public menu and restaurant data, and use it for legitimate market, pricing or
menu research. Do not use it to contact restaurants at scale, to build a competing listing
that copies the platform's content wholesale, or in any way that breaks Yemeksepeti's terms
or local law. Restaurant and menu data changes often, so date your snapshots.

# Actor input Schema

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

Restaurants to scrape directly, one per line. Paste restaurant URLs such as https://www.yemeksepeti.com/restaurant/awhi/eyup-sultan-sofrasi-awhi or bare codes such as awhi. Leave empty to discover restaurants from `locations` instead. An entry that is neither a restaurant URL nor a code becomes its own error row and the run continues.

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

Find restaurants near a place instead of pasting codes. Each entry is a city preset name (Istanbul, Ankara, Izmir, Antalya, Bursa) or a "lat,lng" pair such as 41.0082,28.9784. Ignored when restaurant URLs or codes are given. Empty input falls back to Istanbul.

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

restaurants: one row per restaurant with rating, reviews, fees, minimum order, offers and hours. menus: that same restaurant row plus one row per menu item size (each orderable size is its own row) with TRY prices.

## `maxRestaurants` (type: `integer`):

Total number of restaurants to collect across all locations in discovery mode (1-3000). Restaurants are taken in the platform's listing order, so the cheapest runs are the smallest caps. When you pass restaurant URLs or codes, every entry you give is scraped.

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

Optional square geo-grid around each location: 0 uses only the location point (one listing request per 50 restaurants). Set 3-10 to cover more of a city, with `gridStepKm` controlling the point spacing. Duplicates are removed by restaurant code.

## `gridStepKm` (type: `integer`):

Spacing between grid points when `gridRadiusKm` is greater than 0 (1-10 km). Smaller steps cover a city more densely and cost more listing requests.

## `searchQuery` (type: `string`):

Optional. Keep only restaurants whose name or cuisine contains this text, accent and case-insensitive (doner matches Döner). Applied to the listing in discovery mode.

## `minRating` (type: `number`):

Optional. Keep only restaurants rated at least this (0-5), for example 4.5. Restaurants without a rating are dropped when this is set.

## `maxMenuItemsPerRestaurant` (type: `integer`):

Menus mode only. Cap the number of menu item rows per restaurant (0 = the complete menu). Menu item rows are not billed per row, so 0 is fine for most runs.

## `includeOptions` (type: `boolean`):

Menus mode only. Attach the option groups of each item (extras, dough, size choices...) with their prices to the item row as `optionGroups`.

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

Used only for restaurant detail and menu requests; restaurant discovery from a location needs no proxy. The default, Apify residential proxy in Turkey, is the tested setting: the menu API blocks repeated requests from one datacentre IP after a few calls. Proxy traffic is included in the price. Turn Apify Proxy off only for a quick test, the menu API will answer 403 to this machine.

## Actor input object example

```json
{
  "locations": [
    "Istanbul"
  ],
  "mode": "restaurants",
  "maxRestaurants": 20,
  "gridRadiusKm": 0,
  "gridStepKm": 3,
  "maxMenuItemsPerRestaurant": 0,
  "includeOptions": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}
```

# Actor output Schema

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

One row per restaurant: rowType, restaurantCode, restaurantId, name, url, cuisines, rating, reviewCount, reviewWithCommentCount, priceLevel, address, city, postCode, latitude, longitude, distanceKm, minimumOrderAmount, deliveryFee, deliveryTimeMinutes, isActive, isDeliveryEnabled, isPickupEnabled, isNew, isPromoted, chainName, chainCode, offers, openingHours, logoUrl, website, currency, searchLocation, scrapedAt. Filter rowType=restaurant.

## `menuItems` (type: `string`):

Menus mode: rowType=menuItem, restaurantCode, restaurantName, menuName, categoryName, productId, productName, productDescription, variationId, variationName, price, priceBeforeDiscount, discountPercent, containerPrice, isSoldOut, isAlcoholic, isVegetarian, isPopular, imageUrl, optionGroups, currency, scrapedAt. One row per orderable size.

## `notes` (type: `string`):

Uncharged note rows: rowType=error or info with inputValue plus error or message.

# 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": [
        "Istanbul"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "TR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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": ["Istanbul"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "TR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/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": [
    "Istanbul"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}' |
apify call subimpact/yemeksepeti-scraper --silent --output-dataset

```

## MCP server setup

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