# Konga Scraper (`crawlerbros/konga-scraper`) Actor

Scrape Konga.com - Nigeria's leading online shopping marketplace. Search by keyword or browse Konga's real product categories, filter by price range in NGN, and sort results. Get product names, prices, discounts, ratings, sellers, and images. No login required.

- **URL**: https://apify.com/crawlerbros/konga-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

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

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

Scrape **Konga.com** — Nigeria's leading online shopping marketplace. Search by keyword or browse Konga's real product categories, filter by price range in Nigerian Naira (NGN), and sort by price or rating. Get product names, prices, discounts, ratings, sellers, stock status, and images — all from Konga's public storefront, no login required.

### What this actor does

- **Two modes:** `search` (keyword) and `browseCategory` (Konga's real top-level taxonomy)
- **Price range filter** in NGN, combinable with keyword search or category browse
- **Sort order:** relevance, price low-to-high, price high-to-low, or customer rating
- **Rich product data:** current price, discount percentage, seller, stock status, ratings, and category path
- **Empty fields are omitted** — you'll never see `null`, `""`, or `[]` in the output

### Output per product

- `productId`, `sku`, `name`, `brand`
- `priceNgn` — original listed price
- `specialPriceNgn` — discounted price, if on sale
- `finalPriceNgn` — the price a buyer actually pays; `currency: "NGN"`
- `discountPercent` — computed when a special price applies
- `ratingAverage`, `ratingCount`
- `inStock`, `stockQuantity`
- `categoryTopLevel`, `categoryPath` — deepest matched category breadcrumb
- `attributes` — extra product attributes Konga publishes (color, brand, etc.), when available
- `seller` — `{ name, city, state, isPremium }`
- `isOfficialStore`, `isKongaFulfilled`, `isPayOnDelivery`, `isFreeShipping`, `expressDelivery`
- `availabilityLocations` — pickup/delivery hub locations, when published
- `promoLabel` — e.g. "Hot Deal", when active
- `description` — plain-text product description (HTML stripped, truncated)
- `imageUrl`, `productUrl`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` (keyword) or `browseCategory` (taxonomy browse) |
| `searchQuery` | string | `phone` | Keyword to search for (mode=search) |
| `category` | select | – | One of Konga's real top-level categories (required for `browseCategory`; optional narrowing filter for `search`) |
| `priceMinNgn` | int | – | Minimum price in NGN |
| `priceMaxNgn` | int | – | Maximum price in NGN |
| `sortBy` | select | `relevance` | `relevance` / `priceLowToHigh` / `priceHighToLow` / `topRated` |
| `maxItems` | int | `20` | Maximum number of products to return (1–1000) |
| `proxyConfiguration` | proxy | AUTO | Optional — see Data Source / Limitations |

#### Example: keyword search

```json
{
  "mode": "search",
  "searchQuery": "smartphone",
  "maxItems": 20
}
````

#### Example: browse a category with a price range

```json
{
  "mode": "browseCategory",
  "category": "Electronics",
  "priceMinNgn": 10000,
  "priceMaxNgn": 50000,
  "sortBy": "priceLowToHigh",
  "maxItems": 30
}
```

#### Example: top-rated products in a category

```json
{
  "mode": "browseCategory",
  "category": "Home and Kitchen",
  "sortBy": "topRated",
  "maxItems": 25
}
```

#### Example: keyword search narrowed to a category and price ceiling

```json
{
  "mode": "search",
  "searchQuery": "speaker",
  "category": "Electronics",
  "priceMaxNgn": 20000,
  "maxItems": 20
}
```

### Use cases

- **Price monitoring** — track NGN pricing and discounts across categories over time
- **Market research** — analyze Nigerian e-commerce catalog breadth by category
- **Competitor benchmarking** — compare Konga listings against other Nigerian marketplaces
- **Deal aggregation** — surface discounted / top-rated products for a niche
- **Seller intelligence** — see which sellers and fulfilment types dominate a category

### Data source / limitations

- Data comes from Konga's public search backend — the same service konga.com's own website calls to render search results in a visitor's browser. No login, cookies, or paid API key are required; the search key used is a public, read-only key that Konga publishes to every site visitor's browser.
- Category values reflect Konga's actual live taxonomy at the time of research; if Konga adds or renames a top-level category, this actor's `category` enum may need an update.
- Apify's free datacenter (AUTO) proxy pool does not currently offer a Nigeria (NG) country option. This actor works reliably from any datacenter IP (no Nigeria-specific IP is required to reach Konga's public search backend), so results are complete either way — geo-pinning to Nigeria would only matter for testing Nigeria-specific redirects or currency display, which this actor already normalizes to NGN regardless of request origin.
- Product descriptions are truncated to keep dataset rows a reasonable size.

### FAQ

**Is this affiliated with Konga?**
No. This is an independent, third-party actor that reads Konga's public search results. It is not affiliated with, endorsed by, or sponsored by Konga.

**Do I need an account, cookies, or an API key?**
No. All data returned is publicly visible to any visitor of konga.com without logging in.

**Why NGN only?**
Konga is a Nigeria-focused marketplace and prices its entire catalog in Nigerian Naira.

**Can I combine `searchQuery` and `category`?**
Yes — in `search` mode, setting both narrows keyword results to a specific category.

**What happens if my filters match nothing?**
The actor finishes successfully with 0 records and a clear status message — it will not error or crash.

**How current is the pricing?**
Prices, discounts, and stock status are read live from Konga at the time the actor runs.

**Is a proxy required?**
No. Konga's public search backend is reliably reachable without any proxy, and also works with Apify's free AUTO datacenter proxy if configured.

# Actor input Schema

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

What to fetch.

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

(mode=search) Keyword to search for. Optional if `category` is also set, in which case it narrows the category browse.

## `productUrl` (type: `string`):

(mode=productDetail) A Konga product page URL — e.g. the `productUrl` field from a `search` result, such as `https://www.konga.com/product/some-item-123`.

## `category` (type: `string`):

(mode=browseCategory, mode=search) Konga product category (required for mode=browseCategory; optional narrowing filter for mode=search).

## `priceMinNgn` (type: `integer`):

(mode=search, mode=browseCategory) Only return products priced at or above this amount, in Nigerian Naira.

## `priceMaxNgn` (type: `integer`):

(mode=search, mode=browseCategory) Only return products priced at or below this amount, in Nigerian Naira.

## `sortBy` (type: `string`):

(mode=search, mode=browseCategory) How to order results.

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

(mode=search, mode=browseCategory) Maximum number of products to return.

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

Optional proxy. The free Apify datacenter proxy (AUTO) works fine; a proxy is not required. Apify's free datacenter pool does not currently offer a Nigeria (NG) country option, so results are not geo-pinned to Nigeria — see the README for details.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "phone",
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Konga products.

# 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 = {
    "mode": "search",
    "searchQuery": "phone",
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/konga-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 = {
    "mode": "search",
    "searchQuery": "phone",
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/konga-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 '{
  "mode": "search",
  "searchQuery": "phone",
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/konga-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Konga Scraper",
        "description": "Scrape Konga.com - Nigeria's leading online shopping marketplace. Search by keyword or browse Konga's real product categories, filter by price range in NGN, and sort results. Get product names, prices, discounts, ratings, sellers, and images. No login required.",
        "version": "1.0",
        "x-build-id": "odYj4CYQndPMjzqfN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~konga-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-konga-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/crawlerbros~konga-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-konga-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/crawlerbros~konga-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-konga-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "browseCategory",
                            "productDetail"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "(mode=search) Keyword to search for. Optional if `category` is also set, in which case it narrows the category browse.",
                        "default": "phone"
                    },
                    "productUrl": {
                        "title": "Product URL",
                        "type": "string",
                        "description": "(mode=productDetail) A Konga product page URL — e.g. the `productUrl` field from a `search` result, such as `https://www.konga.com/product/some-item-123`."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "Home and Kitchen",
                            "Beauty, Health & Personal Care",
                            "Electronics",
                            "Phones and Tablets",
                            "Power, Automobile & Industrial",
                            "Computers and Accessories",
                            "Konga Fashion",
                            "Books & Media Library",
                            "Baby, Kids and Toys",
                            "Drinks & Groceries",
                            "Sports and Fitness",
                            "Other Categories",
                            "Office & School Supplies",
                            "Yakata",
                            "Deals",
                            "Bulk Products",
                            "Intel Produce Gaming",
                            "Naija Brand",
                            "Samsung Specials"
                        ],
                        "type": "string",
                        "description": "(mode=browseCategory, mode=search) Konga product category (required for mode=browseCategory; optional narrowing filter for mode=search)."
                    },
                    "priceMinNgn": {
                        "title": "Min price (NGN)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "(mode=search, mode=browseCategory) Only return products priced at or above this amount, in Nigerian Naira."
                    },
                    "priceMaxNgn": {
                        "title": "Max price (NGN)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "(mode=search, mode=browseCategory) Only return products priced at or below this amount, in Nigerian Naira."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "topRated"
                        ],
                        "type": "string",
                        "description": "(mode=search, mode=browseCategory) How to order results.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "(mode=search, mode=browseCategory) Maximum number of products to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The free Apify datacenter proxy (AUTO) works fine; a proxy is not required. Apify's free datacenter pool does not currently offer a Nigeria (NG) country option, so results are not geo-pinned to Nigeria — see the README for details.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
