# Getir Groceries Scraper (`notchgrid/getir-groceries-scraper`) Actor

Scrape Getir category products and product detail pages with raw JSON or normalized dataset output.

- **URL**: https://apify.com/notchgrid/getir-groceries-scraper.md
- **Developed by:** [NotchGrid](https://apify.com/notchgrid) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 category product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Getir Category and PDP Scraper do?

**Getir Category and PDP Scraper** fetches product data from the [Getir app](https://play.google.com/store/apps/details?id=com.getir) in two modes: category product lists and product detail pages. It can save complete raw JSON responses to the Key-value store or normalize the responses into Dataset rows.

Run it on Apify to get API access, scheduling, integrations, and monitoring without maintaining your own scraping server. The Actor is optimized for Getir Turkey product data.

### Why use Getir Category and PDP Scraper?

Use this Actor when you need Getir category inventory, product names, prices, product images, product detail fields, brands, and category structure for pricing analysis, catalog monitoring, assortment comparison, market research, or data pipelines. Raw mode is useful when your client or downstream system expects the exact Getir JSON payload. Dataset mode is useful when you want a clean table that can be exported to CSV, Excel, HTML, or JSON.

The Actor supports batch inputs. You can fetch multiple categories in one run or fetch multiple product detail pages by product slug.

### How to use Getir Category and PDP Scraper

1. Open the Actor on Apify.
2. Go to the Input tab.
3. Select `category` or `pdp` as the operation.
4. For `category`, fill `categories` with one or more Getir category names.
5. For `pdp`, fill `productSlugs` with one or more Getir product slugs.
6. Select `raw` if you need full responses, or `dataset` if you need normalized rows.
7. Start the run.
8. For `raw`, open the Key-value store and download records with `category-raw-` or `pdp-raw-` prefixes.
9. For `dataset`, open the Dataset tab and export the rows.

### Input

Category operation:

```json
{
    "operation": "category",
    "categories": ["snacks", "beverages"],
    "productSlugs": [],
    "outputMode": "raw"
}
```

PDP operation:

```json
{
    "operation": "pdp",
    "categories": [],
    "productSlugs": ["kuzeyden-water-xZpQVfSRqd"],
    "outputMode": "raw"
}
```

`operation` is required and must be `category` or `pdp`. When `operation` is `category`, `categories` must be a non-empty array. When `operation` is `pdp`, `productSlugs` must be a non-empty array.

`categories` uses the category input values from the Input tab.

### Supported Getir categories

The current supported Getir Turkey category inputs are:

| Category input      | Description          |
| ------------------- | -------------------- |
| `beverages`         | Beverages            |
| `snacks`            | Snacks               |
| `milk-dairy`        | Milk & Dairy         |
| `fruits-veggies`    | Fruits & Veggies     |
| `breakfast`         | Breakfast            |
| `baked-goods`       | Baked Goods          |
| `ice-cream`         | Ice Cream            |
| `food`              | Food                 |
| `ready-to-eat`      | Ready to Eat         |
| `meat-poultry-fish` | Meat, Poultry & Fish |
| `fit-form`          | Fit & Form           |
| `home-care`         | Home Care            |
| `personal-care`     | Personal Care        |
| `pet-food`          | Pet Food             |
| `home-living`       | Home & Living        |
| `baby-care`         | Baby Care            |
| `sex-health`        | Sex Health           |

`productSlugs` accepts values such as `kuzeyden-water-xZpQVfSRqd`.

`outputMode` is optional. Use `raw` to store complete Getir JSON responses in the default Key-value store. Use `dataset` to store normalized rows in the default Dataset. The default is `raw`.

### Output

In category raw mode, each full category response is stored in the Key-value store using a key like `category-raw-snacks`. A small metadata item is also pushed to the Dataset.

```json
{
    "operation": "category",
    "category": "snacks",
    "categorySlug": "snacks-yboprW2YpZ",
    "outputMode": "raw",
    "rawKey": "category-raw-snacks",
    "rawRecordUrl": "Available in the Actor run output",
    "productCount": 2386,
    "uniqueProductCount": 2315,
    "subCategoryCount": 13,
    "fetchedAt": "2026-09-01T05:00:00.000Z"
}
```

In PDP raw mode, each record is stored using a key like `pdp-raw-kuzeyden-water-xZpQVfSRqd`. The stored JSON contains only the `productDetail` object from the page's Next.js data, including its `status`, `reason`, and `data` fields.

```json
{
    "operation": "pdp",
    "productSlug": "kuzeyden-water-xZpQVfSRqd",
    "outputMode": "raw",
    "rawKey": "pdp-raw-kuzeyden-water-xZpQVfSRqd",
    "rawRecordUrl": "Available in the Actor run output",
    "fetchedAt": "2026-09-01T05:00:00.000Z"
}
```

In dataset mode, category operation produces one unique product per Dataset item. PDP operation produces one product detail row per product slug.

```json
{
    "operation": "pdp",
    "productSlug": "kuzeyden-water-xZpQVfSRqd",
    "id": "603545c9877ea1efbab7dc90",
    "name": "Kuzeyden Water",
    "description": "Official Water Sponsor.",
    "shortDescription": "24 x 500 ml",
    "price": 473.99,
    "priceText": "473.99 TL",
    "struckPrice": 695.76,
    "struckPriceText": "695.76 TL",
    "unitPrice": 19.7496,
    "unitPriceText": "(19.75 TL/piece)",
    "currencyCode": "TRY",
    "imageUrl": "Product image URL",
    "rawProduct": {}
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field                | Description                                             |
| -------------------- | ------------------------------------------------------- |
| `operation`          | `category` or `pdp`                                     |
| `category`           | Friendly input category selected for category operation |
| `categorySlug`       | Getir API category slug used in category operation      |
| `productSlug`        | Getir product slug used in PDP operation                |
| `outputMode`         | Output mode selected for the run                        |
| `rawKey`             | Key-value store record key for raw mode                 |
| `rawRecordUrl`       | API URL for the raw JSON record                         |
| `productCount`       | Product count reported by the category response         |
| `uniqueProductCount` | Unique products after deduplication by product ID       |
| `subCategoryCount`   | Number of subcategories in the category response        |
| `id`                 | Getir product ID                                        |
| `name`               | Product name                                            |
| `brandName`          | Product brand name                                      |
| `description`        | PDP product description                                 |
| `price`              | Numeric product price                                   |
| `priceText`          | Display price text from Getir                           |
| `unitPriceText`      | PDP unit price text                                     |
| `imageUrl`           | Primary product image URL                               |
| `rawProduct`         | Original product object in dataset mode                 |

### Tips or Advanced options

Use `raw` when another system needs the exact Getir response. Use `dataset` when humans need to inspect products in Apify Console or export rows to spreadsheets.

Start with smaller batches when testing. Large categories such as `snacks` can produce multi-megabyte raw responses and thousands of products. Dataset mode deduplicates category products by Getir product ID because the same product may appear in multiple subcategories.

### FAQ, disclaimers, and support

Is scraping Getir legal? This Actor only fetches publicly accessible web app responses, but you are responsible for checking Getir's Terms of Service and your local laws before scraping or using the data.

Why is raw output in Key-value store instead of Dataset? Apify dataset items have per-item size limits and are optimized for table-like records. Key-value store is a better fit for large JSON documents.

If the Actor stops working because Getir changes its API or blocking behavior, open an issue in the Issues tab. Custom changes, additional categories, and downstream formatting can be added as a custom solution.

# Actor input Schema

## `operation` (type: `string`):

Choose whether to fetch category product lists or product detail pages.

## `categories` (type: `array`):

Getir Turkey categories to fetch when operation is category.

## `productSlugs` (type: `array`):

Getir product slugs to fetch when operation is pdp.

## `outputMode` (type: `string`):

Choose raw to save complete Getir JSON responses to the key-value store, or dataset to save normalized rows.

## Actor input object example

```json
{
  "operation": "category",
  "categories": [
    "snacks"
  ],
  "productSlugs": [
    "kuzeyden-water-xZpQVfSRqd"
  ],
  "outputMode": "raw"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `rawResponses` (type: `string`):

No description

## `keyValueStore` (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 = {
    "operation": "category",
    "categories": [
        "snacks"
    ],
    "productSlugs": [
        "kuzeyden-water-xZpQVfSRqd"
    ],
    "outputMode": "raw"
};

// Run the Actor and wait for it to finish
const run = await client.actor("notchgrid/getir-groceries-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 = {
    "operation": "category",
    "categories": ["snacks"],
    "productSlugs": ["kuzeyden-water-xZpQVfSRqd"],
    "outputMode": "raw",
}

# Run the Actor and wait for it to finish
run = client.actor("notchgrid/getir-groceries-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 '{
  "operation": "category",
  "categories": [
    "snacks"
  ],
  "productSlugs": [
    "kuzeyden-water-xZpQVfSRqd"
  ],
  "outputMode": "raw"
}' |
apify call notchgrid/getir-groceries-scraper --silent --output-dataset

```

## MCP server setup

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