# Konga Product Search Scraper (`stealth_mode/konga-product-search-scraper`) Actor

Automate extraction of comprehensive product data from Konga.com, Nigeria's leading e-commerce platform. Capture pricing, inventory, seller information, ratings, and delivery details. Perfect for price monitoring, market research, competitive intelligence, and inventory analysis in West Africa's.

- **URL**: https://apify.com/stealth\_mode/konga-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
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.com Product Search Scraper: Extract Nigerian E-Commerce Data at Scale

**Excerpt:** Automate extraction of comprehensive product data from Konga.com, Nigeria's leading e-commerce platform. Capture pricing, inventory, seller information, ratings, and delivery details. Perfect for price monitoring, market research, competitive intelligence, and inventory analysis in West Africa's digital marketplace.

---

### Understanding Konga.com and Its Market Significance

Konga.com stands as one of Nigeria's largest and most trusted e-commerce platforms, serving millions of customers across West Africa. Founded in 2012, Konga has evolved into a comprehensive marketplace featuring electronics, fashion, home goods, beauty products, and groceries from both international brands and local sellers. The platform's unique position in the Nigerian market, combined with features like Konga Pay, KongaPrime membership, and extensive fulfillment infrastructure, makes it a critical data source for understanding African e-commerce dynamics.

For businesses operating in or targeting Nigerian markets, Konga represents essential competitive intelligence. The platform captures real-time pricing, inventory availability, seller strategies, and consumer demand signals across thousands of product categories. Manual data collection from Konga requires navigating through countless search pages, copying fragmented information, and tracking constantly changing prices and stock levels—an impossible task at scale.

The Konga.com Product Search Scraper automates this entire process, transforming search result pages into structured datasets ready for price analysis, market research, competitor monitoring, or inventory planning. Whether you're a retailer benchmarking prices, a brand monitoring authorized sellers, or a researcher studying e-commerce patterns in emerging markets, this tool provides the foundation for data-driven decisions in Nigeria's digital economy.

### What This Scraper Extracts and Who Benefits

The Konga.com scraper processes product search result pages—the listings displayed after entering search terms or applying category filters. Unlike scrapers requiring individual product URLs, this tool efficiently captures multiple products from search pages, making it ideal for building comprehensive datasets across categories, brands, or price ranges.

**Key Data Categories Extracted:**

**Product Identification:** Product ID, Object ID, SKU, and URL Key enable precise tracking and database integration for inventory management systems.

**Pricing Intelligence:** Original Price, Final Price, Deal Price, Special Price, and price validity dates (Special From/To Date, New From/To Date) reveal promotional strategies and pricing patterns critical for competitive analysis.

**Product Information:** Name, Description, Brand, Tags, and Categories provide comprehensive product classification for catalog management and market segmentation.

**Visual Assets:** Image Thumbnail, Image Thumbnail Path, Image Full, and complete Images arrays deliver visual content for display systems and image-based analysis.

**Inventory & Fulfillment:** Stock status, Konga Fulfilment Type, Warehouse Location Regions, and Delivery Days indicate availability and logistics capabilities essential for supply chain planning.

**Seller & Marketplace Data:** Seller information, Is Official Store Product flag, and fulfillment type distinguish between Konga-direct sales, third-party sellers, and authorized brand stores.

**Shipping & Payment:** Is Free Shipping, Is Pay On Delivery, Pay On Delivery availability, and Express Delivery options reveal transaction flexibility affecting conversion rates.

**Product Attributes:** Weight, Product Type, Variants array, Visibility status, and Primary Category ID enable detailed product classification and filtering.

**Customer Metrics:** Product Rating and review data provide social proof indicators for demand forecasting and quality assessment.

**Return & Service Policies:** Max Return Period communicates customer protection terms affecting purchase decisions.

**Target Users and Applications:**

**E-Commerce Retailers** benchmark competitor pricing, monitor stock availability, and identify trending products to optimize their own catalogs and pricing strategies.

**Brand Manufacturers** track authorized sellers, detect unauthorized resellers, monitor pricing compliance (MAP violations), and assess market penetration across Nigeria.

**Market Research Firms** analyze category trends, pricing dynamics, seller ecosystems, and consumer demand patterns in Nigerian e-commerce for client reports and market intelligence.

**Price Comparison Platforms** aggregate Konga data with other Nigerian marketplaces (Jumia, Slot) to build comprehensive shopping comparison tools.

**Inventory Planners** track stock levels and delivery times across regions to forecast demand and optimize purchasing decisions.

**Digital Marketers** identify high-demand products, analyze promotional patterns, and discover advertising opportunities based on category performance.

**Financial Analysts** studying African e-commerce growth can analyze product availability, pricing trends, and marketplace dynamics as economic indicators.

### Input Configuration: Targeting Product Searches

The scraper processes Konga search result page URLs—pages displaying multiple products after search queries or category navigation. Understanding URL structure and parameters ensures precise data targeting.

**Example Input Configuration:**
```json
{
  "proxy": {
    "useApifyProxy": false
  },
  "max_items_per_url": 20,
  "ignore_url_failures": true,
  "urls": [
    "https://www.konga.com/search?search=shoe&page=2"
  ]
}
````

#### Example Screenshot:

![](https://i.ibb.co/PZ5Ppjws/Screenshot-from-2025-12-27-02-35-16.png)

**Parameter Breakdown:**

**proxy configuration:** Set to `false` by default for basic scraping. Enable Apify proxy (`useApifyProxy: true`) with residential proxies for large-scale operations to avoid detection. Konga, like most major e-commerce platforms, implements bot detection—proxy rotation becomes essential for scraping hundreds or thousands of products. Small occasional runs (under 100 products) typically work without proxies, while daily monitoring or comprehensive catalog scraping benefits significantly from proxy infrastructure.

**max\_items\_per\_url:** Controls extraction quantity per search page. Setting to 20 captures up to 20 products from each URL. Konga typically displays 20-40 products per search page depending on layout and filters. Higher values (50-100) ensure complete page capture even as display counts vary. For testing, start with lower values (10-15) to verify data quality before scaling.

**ignore\_url\_failures:** When `true`, the scraper continues processing remaining URLs even if some fail due to network issues, expired searches, or temporarily unavailable pages. Critical for batch processing multiple search URLs—prevents one broken URL from halting your entire data collection job. Set to `false` only when every URL must succeed (rare scenarios requiring guaranteed complete data).

**urls array:** Contains Konga search result page URLs. Each URL represents a specific search query, category, or filter combination. Include multiple URLs to collect diverse product segments in a single scraping run—different categories, brands, price ranges, or search terms.

**Understanding Konga URL Structure:**

- `search=shoe` indicates the search query (keyword-based search)
- `page=2` specifies pagination—modify this to scrape multiple result pages
- Additional parameters may include category filters, price ranges, ratings, or seller types
- Category URLs follow patterns like `/category/electronics-123/` or `/category/fashion-456/`

**Pro Tips for URL Selection:**

Perform manual searches on Konga first to verify that filters return relevant products matching your research goals. Copy those URLs directly into your configuration. For comprehensive datasets spanning multiple pages, systematically create URLs with different page numbers: `page=1`, `page=2`, `page=3`, etc.

When targeting specific categories, navigate to category pages and apply relevant filters (price, brand, rating) before copying URLs. This ensures you collect precisely the product segment needed rather than generic broad searches.

### Complete Output Structure: Understanding Every Data Field

The scraper returns JSON data with each product as a detailed object. Understanding field meanings enables effective analysis, database integration, and business intelligence.

**Product Identification Fields:**

- **Product ID:** Konga's unique identifier for the product listing. **Purpose:** Primary key for databases, tracking specific products over time, linking to Konga's internal systems, avoiding duplicates when merging multiple scrapes.

- **Object ID:** Internal object identifier in Konga's database schema. **Purpose:** Technical tracking, API integration, backend system references.

- **SKU (Stock Keeping Unit):** Seller or manufacturer's product code. **Purpose:** Inventory management, cross-referencing with supplier systems, identifying exact product variants, matching across multiple platforms.

- **URL Key:** SEO-friendly URL slug for the product page. **Purpose:** Generating direct product links, SEO analysis, content management system integration.

**Pricing Fields:**

- **Original Price:** Manufacturer's suggested retail price or base listing price before discounts. **Purpose:** Calculating discount percentages, understanding markup structures, detecting price manipulation.

- **Final Price:** Actual current selling price after all discounts and promotions. **Purpose:** Core metric for price comparison, competitive analysis, consumer decision modeling.

- **Deal Price:** Special promotional price for limited-time deals. **Purpose:** Identifying flash sales, tracking promotional strategies, deal alert systems.

- **Special Price:** Temporary reduced price different from standard pricing. **Purpose:** Promotional analysis, seasonal pricing patterns, margin calculations.

- **Price:** Current active price (may match Final Price or Special Price depending on promotions). **Purpose:** Real-time pricing for comparison tools, dynamic pricing analysis.

- **Special From Date / Special To Date:** Start and end timestamps for special pricing periods. **Purpose:** Tracking promotion durations, forecasting pricing changes, analyzing seasonal discount patterns.

- **New From Date / New To Date:** Period during which product is marked as "new." **Purpose:** Product launch tracking, new inventory monitoring, freshness indicators for recommendations.

**Product Information Fields:**

- **Name:** Product title as displayed on Konga. **Purpose:** Product identification, search optimization, catalog display, keyword extraction for market research.

- **Description:** Full product description including features, specifications, and marketing copy. **Purpose:** Detailed product understanding, feature extraction through NLP, content quality analysis, SEO evaluation.

- **Brand:** Manufacturer or brand name. **Purpose:** Brand-level analysis, manufacturer market share calculations, authorized seller verification, brand performance tracking.

- **Tags:** Keyword tags associated with the product. **Purpose:** Search optimization analysis, product categorization, trend identification through tag frequency analysis.

- **Categories:** Hierarchical category classifications (e.g., Electronics > Computers > Laptops). **Purpose:** Product taxonomy analysis, category-level pricing comparisons, market segmentation, navigation structure optimization.

- **Primary Cat ID:** Main category identifier in Konga's taxonomy. **Purpose:** Database relationships, category-based filtering, market share calculations by category.

- **Product Type:** Classification such as simple product, configurable product, or grouped product. **Purpose:** Understanding product complexity, variant management, inventory system integration.

**Visual Asset Fields:**

- **Image Thumbnail:** Small preview image URL. **Purpose:** Quick visual reference, list view displays, bandwidth-efficient loading.

- **Image Thumbnail Path:** Server path to thumbnail image. **Purpose:** Image management, CDN analysis, asset organization.

- **Image Full:** Full-resolution product image URL. **Purpose:** High-quality displays, detailed product viewing, image analysis for features.

- **Images:** Complete array of all product images. **Purpose:** Comprehensive visual documentation, image quality assessment, multi-angle product analysis, visual merchandising evaluation.

**Inventory & Fulfillment Fields:**

- **Stock:** Current stock availability status (in stock, out of stock, limited stock). **Purpose:** Availability tracking, demand forecasting, inventory turnover analysis, restock monitoring.

- **Konga Fulfilment Type:** Indicates fulfillment method (Konga fulfilled, seller fulfilled, hybrid). **Purpose:** Understanding logistics models, delivery speed prediction, service quality assessment, operational cost implications.

- **Warehouse Location Regions:** Geographic regions where inventory is stored. **Purpose:** Regional availability analysis, delivery time estimation, supply chain optimization, market penetration mapping.

- **Delivery Days:** Expected delivery timeframe. **Purpose:** Logistics performance tracking, competitive delivery comparison, customer expectation management.

**Seller & Marketplace Fields:**

- **Seller:** Name or identifier of the product seller. **Purpose:** Seller performance analysis, authorized retailer verification, marketplace ecosystem mapping, seller reputation tracking.

- **Is Official Store Product:** Boolean indicating if product is from brand's official store. **Purpose:** Authenticity verification, authorized seller identification, brand protection, premium pricing analysis.

**Shipping & Payment Fields:**

- **Is Free Shipping:** Boolean indicating free shipping availability. **Purpose:** Total cost calculations, shipping strategy analysis, conversion optimization insights.

- **Is Pay On Delivery:** Boolean showing if cash on delivery is available. **Purpose:** Payment flexibility analysis (critical in Nigerian market where COD is prevalent), risk assessment, conversion rate factors.

- **Pay On Delivery:** Detailed payment on delivery terms and conditions. **Purpose:** Understanding transaction terms, risk management, customer trust indicators.

- **Express Delivery:** Fast shipping option availability. **Purpose:** Premium service analysis, delivery speed competitive intelligence, logistics capability assessment.

**Customer & Quality Fields:**

- **Product Rating:** Average customer rating score. **Purpose:** Quality indicators, demand prediction, review-based filtering, seller performance metrics.

- **Status:** Product listing status (active, inactive, discontinued). **Purpose:** Catalog health monitoring, lifecycle tracking, availability forecasting.

- **Visibility:** Product visibility settings (catalog, search, both). **Purpose:** SEO strategy analysis, merchandising tactics, product launch strategies.

**Return & Service Fields:**

- **Max Return Period:** Maximum days allowed for product returns. **Purpose:** Customer protection analysis, category risk assessment, seller policy comparison.

**Product Variants:**

- **Variants:** Array of product variations (colors, sizes, configurations). **Purpose:** SKU-level analysis, inventory complexity assessment, pricing variation tracking, demand forecasting by variant.

- **Weight:** Product shipping weight. **Purpose:** Logistics cost calculations, shipping strategy analysis, product segmentation by weight class.

**Sample Output Structure:**

```json
[
  {
  "brand": null,
  "deal_price": null,
  "description": "[object Object]",
  "final_price": null,
  "image_thumbnail": "/Z/W/234368_1753908227.jpg",
  "image_thumbnail_path": "/Z/W/234368_1753908227.jpg",
  "image_full": null,
  "images": null,
  "name": " Shoe Rack - 9 Layers",
  "object_id": null,
  "original_price": null,
  "product_id": "6805545",
  "product_type": "simple",
  "price": 74500,
  "status": null,
  "special_price": 60000,
  "sku": "6805545",
  "tags": {
    "konga_promo_label": [],
    "non_returnable": false
  },
  "primary_cat_id": 9903,
  "url_key": "shoe-rack-9-layers-6805545",
  "weight": null,
  "categories": [
    {
      "id": 602,
      "name": "Home and Kitchen",
      "url_key": "home-kitchen",
      "position": 4
    },
    {
      "id": 2993,
      "name": "Home Furnishings",
      "url_key": "home-furnishings",
      "position": 1
    },
    {
      "id": 3073,
      "name": "Decor",
      "url_key": "home-decor",
      "position": 0
    },
    {
      "id": 3065,
      "name": "Storage & Organisation",
      "url_key": "storage-organisation",
      "position": 0
    },
    {
      "id": 9903,
      "name": "Shoe Organizers",
      "url_key": "shoes-organizers",
      "position": 8
    }
  ],
  "variants": {
    "attributes": []
  },
  "visibility": 4,
  "new_from_date": "",
  "new_to_date": "",
  "konga_fulfilment_type": "SHQ",
  "is_free_shipping": false,
  "is_pay_on_delivery": true,
  "seller": {
    "id": 234368,
    "name": "Gemmylinkresources",
    "url": null,
    "is_premium": false,
    "is_konga": false,
    "ratings": {
      "merchant_id": 234368,
      "seller_since": "1 Year",
      "quantity_sold": 80,
      "quality": {
        "one_star": 0,
        "two_star": 0,
        "three_star": 0,
        "four_star": 1,
        "five_star": 5,
        "average": 4.8,
        "percentage": 96,
        "number_of_ratings": 6
      },
      "communication": {
        "one_star": 2,
        "two_star": 0,
        "three_star": 0,
        "four_star": 0,
        "five_star": 0,
        "average": 1,
        "percentage": 20,
        "number_of_ratings": 2
      },
      "delivery_percentage": 64,
      "delivered_orders": 62,
      "total_ratings": 6
    }
  },
  "stock": {
    "in_stock": true,
    "quantity": 10,
    "quantity_sold": 0,
    "min_sale_qty": 1,
    "max_sale_qty": 0
  },
  "product_rating": {
    "quality": {
      "one_star": 0,
      "two_star": 0,
      "three_star": 0,
      "four_star": 0,
      "five_star": 0,
      "average": 0,
      "percentage": 0,
      "number_of_ratings": 0
    },
    "communication": {
      "one_star": 0,
      "two_star": 0,
      "three_star": 0,
      "four_star": 0,
      "five_star": 0,
      "average": 0,
      "percentage": 0,
      "number_of_ratings": 0
    },
    "delivery_percentage": 0,
    "delivered_orders": 0,
    "total_ratings": 0
  },
  "express_delivery": false,
  "special_from_date": "1762041600",
  "special_to_date": "",
  "max_return_period": null,
  "delivery_days": 14,
  "warehouse_location_regions": null,
  "pay_on_delivery": null,
  "is_official_store_product": 0,
  "from_url": "https://www.konga.com/search?search=shoe&page=2"
}
]
```

### Step-by-Step Implementation Guide

**1. Define Your Research Objectives:** Identify exactly what product data you need—specific categories (electronics, fashion, home goods), brands, price ranges, or search terms. Clarify your use case: price monitoring, inventory tracking, market research, or competitive analysis. Clear objectives prevent collecting irrelevant data.

**2. Conduct Test Searches:** Before scraping, perform manual searches on Konga.com using your target keywords, categories, or filters. Verify that search results return relevant products matching your criteria. This validation step prevents wasting resources scraping irrelevant pages.

**3. Collect Target URLs:** Copy URLs from your manual searches. For comprehensive data collection, create multiple URLs representing different search terms, categories, price filters, or brands. For deep extraction across many results, include pagination URLs by incrementing `page=1`, `page=2`, `page=3`, etc.

**4. Configure Input Parameters:** Build your JSON configuration with collected URLs. Set `max_items_per_url` based on needs—20 for standard extraction, 40-50 for thorough scraping. Enable `ignore_url_failures: true` for resilience when processing multiple URLs. For large-scale scraping (500+ products), enable proxy configuration to avoid detection.

**5. Launch and Monitor Scraping:** Start your scraping run through the Apify console and monitor real-time progress. Typical processing time: 5 search pages with 20 items each complete in 3-6 minutes, varying with Konga's server response times and connection quality. Check logs for any errors or blocked requests.

**6. Validate Data Quality:** Preview results in the dataset tab. Verify that critical fields (prices, product names, stock status, seller information) are populated correctly. Check for missing data patterns—if many products lack certain fields, adjust extraction logic or URL targeting.

**7. Export and Process Data:** Export in your preferred format—JSON for database integration, CSV for Excel analysis, or direct API access for automated systems. Clean data by removing duplicates (same Product ID), filtering by stock availability, or segmenting by category.

**8. Implement Systematic Pagination:** For large category datasets (hundreds of products), calculate required pages by checking Konga's displayed result count (e.g., "Showing 1-20 of 500 results" means 25 pages needed). Create URLs for all pages to ensure complete data coverage.

**Error Prevention Tips:**

- Ensure URLs are search result pages, not individual product detail pages or homepage
- Verify URLs load properly in your browser before adding to scraper configuration
- Check that Konga hasn't changed search URL structure (rare but possible)
- Start with small batches (2-3 URLs) to test before scaling to hundreds
- Monitor stock status fields—"Out of Stock" products may have incomplete data

**Scaling Best Practices:**

- For datasets exceeding 1,000 products, split into multiple runs (300-500 products each) to improve reliability and avoid timeouts
- Schedule recurring scraping (daily or weekly) for ongoing price monitoring rather than massive one-time extractions
- Use proxy rotation for daily scraping to avoid IP-based rate limiting
- Implement data versioning to track changes over time—store scrape timestamp with each dataset

### Strategic Applications for Nigerian E-Commerce Intelligence

**Dynamic Price Monitoring:** Track competitor pricing in real-time across categories. Calculate average market prices, identify pricing outliers, and detect promotional patterns. Monitor Special Price dates to anticipate competitor promotions. Set up automated alerts when competitor prices drop below your threshold, enabling rapid strategic responses.

**Inventory Availability Tracking:** Monitor stock status across high-demand products or competitor catalogs. Identify frequently out-of-stock items indicating strong demand or supply chain issues. Track warehouse location regions to understand geographic inventory distribution. Forecast restocking patterns based on historical stock availability data.

**Seller Ecosystem Analysis:** Analyze seller distribution across categories. Identify dominant sellers by product count and pricing power. Track Official Store products versus third-party sellers to understand marketplace dynamics. Detect unauthorized sellers for brand protection. Calculate seller concentration ratios to assess marketplace competitiveness.

**Promotional Strategy Intelligence:** Extract Special From/To Date patterns to map competitor promotional calendars. Identify seasonal discount trends (holidays, end-of-month sales). Calculate average discount percentages by category. Understand which product types receive deepest discounts and when. Time your own promotions to avoid or counter competitor campaigns.

**Brand Presence and Compliance:** Manufacturers can track all sellers offering their products. Verify authorized retailers through Official Store flags. Detect MAP (Minimum Advertised Price) violations by comparing Final Prices against brand policies. Monitor product descriptions and images for brand guideline compliance. Identify gray market sellers or counterfeit listings.

**Category Performance Analysis:** Aggregate product counts, average prices, and rating distributions by category. Identify high-growth categories based on new product additions. Understand category pricing dynamics—premium versus budget segments. Discover underserved niches with few products but high demand indicators.

**Delivery and Fulfillment Competitiveness:** Compare delivery days across sellers and fulfillment types. Identify regions with fast delivery (warehouse location analysis). Understand Konga fulfillment versus seller fulfillment performance. Analyze express delivery availability by category to assess service levels.

**Payment Method and Shipping Strategy:** Track pay-on-delivery availability across product segments—critical in Nigerian market where COD dominates. Analyze free shipping patterns by price point and category. Calculate true total cost including shipping for accurate price comparisons. Identify optimal price thresholds for free shipping offers.

**Product Launch and Lifecycle Tracking:** Monitor New From/To Dates to identify recently launched products. Track product status changes from active to inactive, revealing discontinued items. Analyze product lifecycle duration by category. Identify fast-moving new products based on early ratings and stock depletion.

### Advanced Data Analysis Techniques

**Time-Series Price Analytics:** Scrape same product searches daily or weekly, storing data with timestamps. Build historical price databases tracking individual products over time. Calculate price volatility metrics, identify seasonal patterns, and predict optimal purchase timing. Detect price matching strategies where competitors mirror each other's pricing.

**Competitive Positioning Matrices:** Plot products on price-rating charts to visualize quality-value positioning. Identify market gaps—high-demand segments with few offerings. Understand premium versus budget competitive landscapes. Guide product development or sourcing decisions based on white space analysis.

**Demand Forecasting:** Combine product ratings (demand signal), stock status (supply constraint), and special pricing (promotional impact) to forecast product demand. Products with high ratings, frequent stock-outs, and minimal discounting indicate strong organic demand. Low-rated products requiring heavy discounting signal weak demand.

**Brand Penetration Analysis:** Calculate brand market share by product count and aggregate sales estimates. Identify emerging brands with growing product listings. Track brand positioning through average price points. Analyze brand strategy—premium pricing with official stores versus wide distribution through third-party sellers.

**Visual Content Analysis:** Process image arrays with computer vision to extract product attributes not in text fields. Detect image quality levels correlating with seller professionalism. Identify products with insufficient images (fewer than 3) indicating poor merchandising. Analyze image consistency for brand presentation standards.

**Description and Tag Mining:** Apply natural language processing to product descriptions extracting key features, materials, and benefits. Build feature frequency analysis revealing trending product attributes. Extract sentiment from marketing language. Compare description quality across sellers, identifying professional versus amateur listings.

**Variant Strategy Intelligence:** Analyze variant arrays to understand SKU complexity across categories. Calculate price premiums for different variants (color, size). Identify most popular variants based on stock levels. Understand optimal variant offering breadth—too few limits choice, too many creates complexity.

**Cross-Category Pricing Patterns:** Identify products appearing in multiple categories with different pricing (arbitrage opportunities). Calculate category-level markup patterns. Understand price anchoring strategies—expensive items listed to make mid-range items appear reasonable.

**Seller Performance Clustering:** Segment sellers by metrics—product count, average rating, fulfillment type, official store status. Identify high-performing seller characteristics. Guide seller partnership or acquisition targets. Understand seller growth trajectories based on catalog expansion rates.

### Data Governance and Best Practices

**Scraping Frequency Optimization:** Nigerian e-commerce updates rapidly, especially pricing and stock levels. Daily scraping suits competitive price monitoring in fast-moving categories (electronics, fashion). Weekly scraping balances data freshness with resource efficiency for market research. Monthly scraping works for broad trend analysis or stable categories. Consider Konga's business cycle—higher activity mid-month (payday) and during promotional periods.

**Data Freshness Validation:** Track scrape timestamps rigorously. Flag stale data (more than 7 days old for prices, 30 days for catalog structure). Compare extracted dates (Special To Date, New To Date) against scrape time to validate current relevance. Implement data expiration policies in your databases.

**Privacy and Legal Compliance:** Product data is generally public commercial information, but seller contact details may fall under personal data protection. Handle data securely with appropriate access controls. Use data only for legitimate business purposes—competitive analysis, market research, price comparison. Avoid republishing scraped content without transformation or added value. Respect Konga's terms of service and implement reasonable rate limiting.

**Duplicate Detection and Management:** Products may appear across multiple search pages with overlapping filters. Use Product ID as primary key for deduplication. Consider keeping duplicates initially for search ranking analysis—products appearing in multiple searches indicate high relevance. Consolidate in final analysis databases.

**Currency and Pricing Context:** All prices in Nigerian Naira (NGN). When storing data long-term, note scrape date for inflation adjustment—Nigeria experiences significant currency fluctuation. Validate extreme prices (outliers) that might indicate data errors, misclassified products, or pricing mistakes. Cross-reference suspicious pricing with manual checks.

**Stock Status Interpretation:** "In Stock" may not guarantee immediate availability across all regions given Nigeria's logistics challenges. "Limited Stock" often indicates high demand or restocking cycles. "Out of Stock" for extended periods may signal discontinued products. Track stock status changes over time to understand true availability patterns versus optimistic status labels.

**Regional Considerations:** Warehouse location regions significantly impact delivery times in Nigeria given infrastructure variations. Products available in Lagos may have different delivery times to other regions. Consider regional analysis segmentation for accurate logistics intelligence.

**Quality Assurance Checks:** Implement validation rules—prices must be positive numbers, Product IDs should follow Konga's format patterns, categories should match known taxonomy. Flag anomalies like products with prices but no names, missing images for active listings, or inconsistent variant data. Review flagged records manually before analysis.

**Rating and Review Context:** Product ratings provide demand signals but may be limited in volume for new products. High ratings with few reviews may indicate early adopter bias. Consider rating volume alongside score. Be aware that ratings may be manipulated—look for patterns of suspiciously uniform ratings.

**Ethical Scraping Practices:** Implement respectful rate limiting (avoid overwhelming Konga's servers). Add delays between requests especially when not using proxies. Monitor for and respect robots.txt directives. Scrape during off-peak hours when possible to minimize impact on regular users. Consider ethical implications of competitive intelligence use.

### Conclusion

The Konga.com Product Search Scraper transforms Nigeria's leading e-commerce marketplace into structured, actionable business intelligence. From real-time pricing dynamics enabling competitive strategy to inventory patterns revealing demand trends, this tool delivers comprehensive insights into West Africa's digital retail landscape. Whether you're optimizing retail operations, protecting brand integrity, conducting market research, or building price comparison platforms, structured Konga data provides the foundation for data-driven decisions in Nigeria's rapidly growing e-commerce ecosystem.

Nigeria's digital economy continues expanding rapidly, with e-commerce projected to reach billions in annual gross merchandise value. Konga, alongside competitors like Jumia, drives this transformation—making systematic data extraction not just valuable but essential for businesses competing in or studying these markets. Start extracting Nigerian e-commerce insights today and gain the competitive intelligence needed to succeed in Africa's digital marketplace revolution.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.konga.com/search?search=shoe&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.konga.com/search?search=shoe&page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/konga-product-search-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 = {
    "urls": ["https://www.konga.com/search?search=shoe&page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/konga-product-search-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 '{
  "urls": [
    "https://www.konga.com/search?search=shoe&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/konga-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Konga Product Search Scraper",
        "description": "Automate extraction of comprehensive product data from Konga.com, Nigeria's leading e-commerce platform. Capture pricing, inventory, seller information, ratings, and delivery details. Perfect for price monitoring, market research, competitive intelligence, and inventory analysis in West Africa's.",
        "version": "0.0",
        "x-build-id": "QpEu5xyWduy26iETf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~konga-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-konga-product-search-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/stealth_mode~konga-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-konga-product-search-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/stealth_mode~konga-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-konga-product-search-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": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
