# Konga Product Data Scraper (`xhimatty/konga-product-data-scraper`) Actor

Extract structured product data from Konga in minutes. Scrape product names, prices, seller information, SKUs, and more. Supports filtered Konga category URLs, making it easy to scrape products by brand, price range, rating, and other supported filters. Export your data as JSON, CSV, or XLSX.

- **URL**: https://apify.com/xhimatty/konga-product-data-scraper.md
- **Developed by:** [Michael Mathias](https://apify.com/xhimatty) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Konga Product Data Scraper

Extract structured product data from Konga categories in minutes.

### Table of Contents
- [Overview](#overview)
- [Who is this Actor for?](#who-is-this-actor-for)
- [Common Use Cases](#common-use-cases)
- [Features](#features)
- [Input](#input)
- [Output](#output)
- [How to Use](#how-to-use)
- [How to Find Konga Category URLs](#how-to-find-konga-category-urls)
- [Export Formats](#export-formats)
- [Performance](#performance)
- [Notes](#notes)
- [Frequently Asked Questions](#frequently-asked-questions)

### Overview
The **Konga Product Data Scraper** extracts detailed product information from a user-specified Konga category. Once you click **Start**, you get product ID, product name, price, special price, deal price, original price, SKU, seller information, stock availability, stock quantity, ratings, free delivery status, and many other product attributes.

What makes this Actor unique is its flexibility, ease of use, and user-friendly design for **Konga**. The Actor supports filtered category URLs, allowing you to scrape products by brand, rating, price range, fulfilment type, and other supported Konga filters, giving  you total control. You decide the number of pages you want scraped, paste the **Konga** category URL, click **Start**, and the Actor collects the data without any hassle or bottlenecks.

Whether you need a few products or an entire category, the Actor automatically handles pagination, extraction, and saves the results to your Apify dataset, ready for download.

### Who is this Actor for?

- E-Commerce businesses
- Market Researchers
- Competitor analysts
- Pricing Analysts
- Data analysts
- Developers
- Businesses building product catalogues
- Anyone who needs structured Konga product data

### Common Use Cases

- Product catalogue collection
- Price monitoring
- Competitor research
- Market research
- Inventory comparison
- Business intelligence
- Building product databases
- E-Commerce analytics

### Features

- **Detailed Konga product information:** Scrapes comprehensive product details including pricing, SKU, seller information, stock availability, product identifiers, and more.
- **Fast Extraction:** Retrieves product data quickly, making it suitable for extracting thousands of products

- **Configurable category URL:** Paste the Konga category URL you want to scrape. Filtered category URLs are also supported (brand, rating, price, fulfilment type, etc.).

- **Configurable maximum pages:** Choose the number of pages you want to scrape or leave the default value '0' to scrape every available page.

- **Automatic Pagination:** Automatically continues until your page limit or the last available page.

- **Export to multiple formats:** Export as **JSON**, **CSV**, or **XLSX**.

### Input

| Input | Type | Required | Default | Description |
|:---|:---:|:---:|:---:|:---|
| `url` | String | Yes | Example URL | Konga category URL to scrape. Filtered category URLs are also supported. |
| `max_pages` | Integer | No | `0` | The maximum number of pages to scrape. `0` scrapes all available pages. |

### Input Example

```json
{
    "url": "https://www.konga.com/category/blenders-juicers-mixers-5226",
    "max_pages": 5
}
````

> \[!TIP]
>
> Set `max_pages` to `0` to scrape every available page.

### Output

Each dataset item represents a single product

```json
{
    "brand": "Kenwood",
    "product": "Industrial Blender With Mill Jar - 4L - 10000W",
    "product_id": "6948793",
    "price": 49500,
    "special_price": 49500,
    "seller_name": "BIG SAM COLLECTION",
    "seller_state": "Lagos",
    "seller_quality_ratings": 4.3,
    "sku": 6948793,
    "in_stock": true,
    "stock_quantity": 19,
    "url": "https://www.konga.com/product/kenwood-industrial-blender-with-mill-jar-4l-10000w-6948793"
}
```

> \[!Note]
>
> Available fields may vary depending on the product.

### How to Use

1. Open the Actor on Apify.

2. Paste the Konga category URL. Filtered category URLs are also supported (brand, rating, price, fulfilment type, etc.).

3. Set the `max_pages` you want scraped or leave it as `0` to scrape all available pages.

4. Click **Start**.

5. Wait for the run to finish.

6. Download the dataset in your preferred format.

### How to Find Konga Category URLs

Go to **konga.com**. Hover over a main category below the search bar and choose a subcategory. See image below
![maincategory](https://i.ibb.co/2Y8tV3Zz/Screenshot2026main.png)

![subcat](https://i.ibb.co/5WfMqyyx/Screenshot2026sub.png)

```text
https://www.konga.com/category/routers-5418
```

### Export Formats

- JSON
- CSV
- XLSX

### Performance

This Actor scrapes product data without browser automation, which makes the extraction process faster while using fewer computing resources.

### Notes

> \[!IMPORTANT]
>
> - Output depends on the publicly available product data.
> - One category is scraped per run.
> - If `max_pages` exceeds the available pages, the actor stops automatically.

### Frequently Asked Questions

- **Can I scrape every page in a category?**
  - Yes. Leave or set `max_pages` to `0`

- **What format can I export?**
  - CSV, XLSX, JSON

- **Do I need an account, cookies, or API key?**
  - No. The Actor does not require a Konga account, cookies, or an API key.

- **Is a proxy required?**
  - No. The Actor works without a proxy because it retrieves publicly available product data directly from Konga.

# Actor input Schema

## `url` (type: `string`):

Paste a Konga category URL. Filtered category URLs are also supported.

## `max_pages` (type: `integer`):

Maximum number of pages to scrape. Set 0 to scrape all available pages.

## Actor input object example

```json
{
  "url": "https://www.konga.com/category/routers-5418",
  "max_pages": 0
}
```

# Actor output Schema

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

Dataset containing the scraped products from Konga.

# 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 = {
    "url": "https://www.konga.com/category/routers-5418"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xhimatty/konga-product-data-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 = { "url": "https://www.konga.com/category/routers-5418" }

# Run the Actor and wait for it to finish
run = client.actor("xhimatty/konga-product-data-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 '{
  "url": "https://www.konga.com/category/routers-5418"
}' |
apify call xhimatty/konga-product-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Konga Product Data Scraper",
        "description": "Extract structured product data from Konga in minutes. Scrape product names, prices, seller information, SKUs, and more. Supports filtered Konga category URLs, making it easy to scrape products by brand, price range, rating, and other supported filters. Export your data as JSON, CSV, or XLSX.",
        "version": "0.1",
        "x-build-id": "vAhyziIhFN2CXAVuF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xhimatty~konga-product-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xhimatty-konga-product-data-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/xhimatty~konga-product-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xhimatty-konga-product-data-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/xhimatty~konga-product-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xhimatty-konga-product-data-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": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "Konga Category URL",
                        "type": "string",
                        "description": "Paste a Konga category URL. Filtered category URLs are also supported."
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape. Set 0 to scrape all available pages.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```