# Kilimall Scraper - Kenya's Online Shopping Platform (`anastasiaw1961/kilimall-scraper`) Actor

Scrape product data from Kilimall.co.ke, Kenya's leading e-commerce marketplace. Extracts product names, prices (current & original), ratings, categories, SKU IDs, store names, and images. Supports search query filtering, sorting by newest/oldest/alphabetical/price, and product discovery.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Kilimall Scraper - Kenya's Online Shopping Platform

Scrape product data from **[Kilimall.co.ke](https://www.kilimall.co.ke/)**, Kenya's leading e-commerce marketplace with over 1 million products across hundreds of categories. Extract product names, prices, ratings, store names, categories, and images — all without JavaScript rendering, making it **fast and cost-efficient**.

The scraper runs on the **Apify platform**, giving you access to scheduled runs, webhook integrations, API access, proxy rotation, and one-click exports to JSON, CSV, HTML, or Excel.

### Why use Kilimall Scraper?

- **Market research** — Track pricing trends across Kilimall's 1M+ products
- **Competitor monitoring** — Compare prices from different sellers on the same products
- **Inventory analysis** — Discover which products are in stock and which stores have the best selection
- **Data-driven shopping** — Find the cheapest products with price-based sorting
- **Category analysis** — Scrape entire categories to understand product landscapes

### How to use Kilimall Scraper

1. Open the [Kilimall Scraper](https://console.apify.com/actors/mBuriuHkIEFy3v3DX) in Apify Console
2. Configure the input (or use defaults):
   - **Discovery Mode**: `Sitemap` (discovers all products automatically) or `Custom URLs` (provide specific product links)
   - **Search Query**: Filter by keyword (e.g., `phone`, `shoes`, `tv`) — leave empty for all products
   - **Sort By**: Choose sorting — Newest, Oldest, A-Z, Z-A, Price Low to High, or Price High to Low
   - **Max Products**: How many to scrape (default: 50, set to 0 for unlimited)
3. Click **Run** and wait for results
4. Download the dataset in your preferred format

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | select | `sitemap` | How to discover products: `Sitemap` (auto-discover from Kilimall's sitemap) or `Custom URLs` (provide specific links) |
| `startUrls` | array | — | Product URLs to scrape (only used in Custom URLs mode) |
| `sitemapUrl` | string | `https://www.kilimall.co.ke/sitemap-index.xml` | Sitemap index URL (only used in Sitemap mode) |
| `searchQuery` | string | empty | Keyword to filter products by name. Uses AND logic — all terms must match. Example: `43 inch tv` |
| `sortBy` | select | `newest` | Sort order: `Newest first`, `Oldest first`, `A-Z`, `Z-A`, `Price: Low to High`, `Price: High to Low` |
| `maxProducts` | integer | `50` | Maximum products to scrape. Use `0` for unlimited |
| `maxConcurrency` | integer | `10` | Number of concurrent requests. Increase for faster scraping (higher server load) |

Example input:

```json
{
  "mode": "sitemap",
  "searchQuery": "samsung phone",
  "sortBy": "price-low-high",
  "maxProducts": 20,
  "maxConcurrency": 10
}
````

### Output

Each scraped product produces a JSON record like this:

```json
{
  "productId": "183465",
  "skuId": "157317092",
  "title": "Samsung Galaxy A14 4G 128GB 4GB RAM",
  "url": "https://www.kilimall.co.ke/listing/183465-samsung-galaxy-a14",
  "imageUrl": "https://img.kilimall.com/gallery/store/...",
  "currentPrice": 3599,
  "originalPrice": 9999,
  "currency": "KES",
  "ratingScore": 5,
  "ratingCount": 120,
  "category": "Home > Electronics & Appliances > Phables & Tablets > Smart Phones > Android Phones",
  "storeName": "Selective",
  "description": null,
  "availability": null,
  "brand": null,
  "scrapedAt": "2026-07-01T06:04:57.077Z"
}
```

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

### Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Kilimall internal product ID |
| `skuId` | string | SKU/variant ID |
| `title` | string | Product name |
| `url` | string | Full product page URL |
| `imageUrl` | string | Main product image URL |
| `currentPrice` | number | Current selling price (KES) |
| `originalPrice` | number | Original/list price (KES), if available |
| `currency` | string | Currency code (always `KES`) |
| `ratingScore` | number | Average customer rating (0–5) |
| `ratingCount` | integer | Number of customer ratings |
| `category` | string | Full breadcrumb category path |
| `storeName` | string | Seller/store name |
| `description` | string | Product description (from JSON-LD when available) |
| `availability` | string | Stock availability status (from JSON-LD when available) |
| `brand` | string | Brand name (from JSON-LD when available) |
| `scrapedAt` | string | ISO timestamp of when the product was scraped |

### Pricing / Cost Estimation

Kilimall Scraper uses **CheerioCrawler**, which consumes 1–3 compute units per 1,000 products scraped (depending on concurrency). Most runs with default settings (50 products) cost under **1 compute unit**. Apify provides a **free monthly usage tier** for new users.

To minimize costs:

- Set `maxConcurrency` to `5` or lower
- Use `searchQuery` to narrow results instead of scraping all products
- Set a reasonable `maxProducts` limit

### Tips & Advanced Options

- **Fastest results**: Use default settings (Sitemap mode, newest first, 10 concurrency)
- **Cheapest products**: Set `sortBy` to `Price: Low to High` — finds the best deals first
- **Full inventory**: Set `maxProducts` to `0` for unlimited scraping (will scrape all matching products)
- **Custom URLs**: In Custom URLs mode, provide product listing URLs like `https://www.kilimall.co.ke/listing/183465-samsung-galaxy-a14`
- **Respectful crawling**: The scraper uses appropriate delays and respects Kilimall's server capacity

### FAQ

**Is scraping Kilimall legal?**\
Kilimall is a publicly accessible e-commerce website. This scraper extracts publicly available product information at a reasonable rate. Users are responsible for complying with Kilimall's Terms of Service and applicable laws.

**Why are some fields null?**\
Fields like `description`, `availability`, and `brand` depend on JSON-LD structured data being present on the product page. Not all Kilimall product pages include this data. The scraper always extracts the fields that are available via text patterns as well.

**Does this require a proxy?**\
No — the scraper will run without a proxy. On the Apify platform, Apify Proxy is automatically used when available (requires a paid Apify plan).

**How many products can I scrape?**\
There are over 1 million product URLs in Kilimall's sitemap. The scraper handles any quantity — just be aware that larger runs consume more compute units.

### Support

For issues, feature requests, or questions, use the **Issues** tab on this Actor's page. Need a custom scraper for a different marketplace? Contact the developer for tailored solutions.

**Disclaimer**: This Actor is not affiliated with, endorsed by, or sponsored by Kilimall. All product names, logos, and brands are property of their respective owners.

# Actor input Schema

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

How to discover product URLs to scrape.

## `startUrls` (type: `array`):

Specific product URLs to scrape. Only used when mode is Custom URLs.

## `sitemapUrl` (type: `string`):

URL of the sitemap index to discover product pages. Only used when mode is Sitemap.

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

Keyword to filter products by (e.g. 'phone', 'shoes', 'tv'). Products whose name matches this term will be scraped. Leave empty to get all products.

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

How to sort the scraped products.

## `maxProducts` (type: `integer`):

Maximum number of products to scrape (0 = unlimited).

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

Maximum number of concurrent requests.

## Actor input object example

```json
{
  "mode": "sitemap",
  "sitemapUrl": "https://www.kilimall.co.ke/sitemap-index.xml",
  "sortBy": "newest",
  "maxProducts": 50,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("anastasiaw1961/kilimall-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("anastasiaw1961/kilimall-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 '{}' |
apify call anastasiaw1961/kilimall-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kilimall Scraper - Kenya's Online Shopping Platform",
        "description": "Scrape product data from Kilimall.co.ke, Kenya's leading e-commerce marketplace. Extracts product names, prices (current & original), ratings, categories, SKU IDs, store names, and images. Supports search query filtering, sorting by newest/oldest/alphabetical/price, and product discovery.",
        "version": "0.4",
        "x-build-id": "q9Mb62jALCaTKSOtX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/anastasiaw1961~kilimall-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-anastasiaw1961-kilimall-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/anastasiaw1961~kilimall-scraper/runs": {
            "post": {
                "operationId": "runs-sync-anastasiaw1961-kilimall-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/anastasiaw1961~kilimall-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-anastasiaw1961-kilimall-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",
                "properties": {
                    "mode": {
                        "title": "Discovery Mode",
                        "enum": [
                            "sitemap",
                            "startUrls"
                        ],
                        "type": "string",
                        "description": "How to discover product URLs to scrape.",
                        "default": "sitemap"
                    },
                    "startUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Specific product URLs to scrape. Only used when mode is Custom URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sitemapUrl": {
                        "title": "Sitemap URL",
                        "type": "string",
                        "description": "URL of the sitemap index to discover product pages. Only used when mode is Sitemap.",
                        "default": "https://www.kilimall.co.ke/sitemap-index.xml"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to filter products by (e.g. 'phone', 'shoes', 'tv'). Products whose name matches this term will be scraped. Leave empty to get all products."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "newest",
                            "oldest",
                            "a-z",
                            "z-a",
                            "price-low-high",
                            "price-high-low"
                        ],
                        "type": "string",
                        "description": "How to sort the scraped products.",
                        "default": "newest"
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to scrape (0 = unlimited).",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of concurrent requests.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
