# Jumia Product Scraper — Prices, SKUs & Sellers (`khadinakbar/jumia-product-scraper`) Actor

Collect public Jumia product records in seven African markets from keywords, categories, or product URLs. Return prices, SKUs, ratings, sellers, and source URLs for catalog comparison.

- **URL**: https://apify.com/khadinakbar/jumia-product-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product scrapeds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Jumia Product Scraper

Collect one structured, source-linked product record for each public Jumia listing or product page. It is designed for catalog analysts, marketplace sellers, and agents that need observed product names, prices, currencies, ratings, sellers, and collection times from Jumia’s supported African markets.

### Best fit for this Actor

- Use this Actor when your starting point is a Jumia keyword, category page, or product URL and the next decision depends on an observed price, SKU, rating, or seller field.
- Start with a focused keyword to discover a market slice, then provide the resulting product URLs when you want detail enrichment for selected items.
- For a cross-market comparison, start with the same brand and model on Jumia, then use the [Amazon Product Scraper](https://apify.com/khadinakbar/amazon-product-scraper) with the matching ASIN, search term, or Amazon URL.

### Workflow: from Jumia search to a price comparison

A marketplace analyst starts with a category keyword such as an air fryer, selects a supported market, and collects a bounded set of product records. The dataset pairs `price`, `currency`, `rating`, `seller`, and `scrapedAt` with each public Jumia `url`. The analyst then compares the observed price band and seller mix, or continues with a matching marketplace collection for a cross-market merchandising decision.

### Quick start input

```json
{
  "searchQueries": ["air fryer"],
  "country": "ng",
  "maxResults": 25,
  "maxPagesPerQuery": 2,
  "enrichDetails": false
}
```

Use `searchQueries` for discovery. Use a Jumia category or product URL when the starting page is already known:

```json
{
  "startUrls": [
    "https://www.jumia.com.ng/phones-tablets/"
  ],
  "maxResults": 25,
  "enrichDetails": true
}
```

### Input reference

| Input | What it controls |
|---|---|
| `searchQueries` | One or more product phrases for discovery in the selected market. |
| `startUrls` | Public Jumia category, listing, or product pages; the market comes from the URL domain. |
| `country` | Market for keyword discovery: `ng`, `ke`, `eg`, `gh`, `ma`, `ci`, or `sn`. |
| `maxResults` | The product-event cap for the run. Use a small value to sample a category or price band. |
| `maxPagesPerQuery` | Listing pages considered for each discovery input. |
| `enrichDetails` | Adds seller, specifications, key features, description, and image-gallery fields from product pages. |
| `proxyConfiguration` | A residential, country-pinned proxy configuration for the Jumia market. |
| `proxyProvider` | `auto` uses Apify Residential and can continue through the configured fallback route. |

### What data you receive

Each dataset item is one public Jumia product observation. `url` preserves the source page, and `scrapedAt` is the collection time for that observation; use both fields when comparing datasets collected at different times.

| Field | Meaning |
|---|---|
| `name`, `brand`, `sku` | Product identity as presented by the source page. |
| `price`, `oldPrice`, `discountPercent`, `currency` | Current pricing fields in the market’s local currency. |
| `rating`, `reviewsCount` | Listing or detail-page rating context. |
| `seller`, `sellerScore` | Seller information when a product detail page is collected. |
| `categoryPath`, `breadcrumbs` | Product placement in the public Jumia catalog. |
| `imageUrl`, `images` | Main image and optional enriched gallery. |
| `url`, `scrapedAt` | Source provenance and collection time. |

```json
{
  "country": "Nigeria",
  "countryCode": "ng",
  "name": "SILVER CREST 8L Extra Large Digital AirFryer",
  "brand": "SILVER CREST",
  "price": 32941,
  "currency": "NGN",
  "rating": 4,
  "reviewsCount": 4638,
  "sku": "SI905HA7SA8WLNAFAMZ",
  "seller": null,
  "url": "https://www.jumia.com.ng/silver-crest-8l-extra-large-digital-airfryer-418507707.html",
  "scrapedAt": "collection-timestamp"
}
```

### Pricing

This Actor uses **Pay per event + Apify platform usage**. A persisted product is the billable unit, and detail enrichment is an additional event when it is requested. `maxResults` provides a product-event cap; platform usage covers the associated compute and proxy work. Open the live Pricing tab for the current event details before a larger collection.

### Use through the API

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("khadinakbar/jumia-product-scraper").call(run_input={
    "searchQueries": ["air fryer"],
    "country": "ng",
    "maxResults": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["price"], item["currency"], item["url"])
```

After collection finishes, read the default key-value store’s `OUTPUT` record for the compact outcome and `RUN_SUMMARY` for input coverage, route, cost, warnings, and pagination diagnostics.

### Use with AI agents through Apify MCP

> Find up to 25 public Jumia Nigeria air-fryer listings. Return name, price, currency, rating, seller, source URL, and collection time. Read the terminal outcome and dataset, preserve provenance, respect the result cap, and report whether the outcome is complete, partial, or empty.

The Actor is read-only. For agent workflows, provide the market and a bounded keyword or public Jumia URL, read the dataset after completion, and retain `url` with `scrapedAt` for provenance. The product cap controls billable product events, while the live Pricing tab describes current event costs and platform usage.

### Best results

| Starting situation | Helpful action | Expected outcome |
|---|---|---|
| A product URL is already known | Provide the canonical public Jumia product URL and enable detail enrichment when seller or specification fields support the decision. | A source-linked product record with current collection time. |
| Discovery starts with a broad category | Start with a specific keyword and a small product cap, then refine the query or category input. | Comparable records for a focused product slice. |
| A recurring comparison is useful | Schedule the same bounded input at the business cadence and compare `price`, `currency`, `inStock`, and `scrapedAt`. | Time-separated observations that support price and assortment review. |

### Builder's note

I designed the output around one product observation per row so a price comparison retains both the local currency and the original Jumia URL. During implementation, the browser route and residential session handling were chosen to keep source collection and dataset readback consistent across the supported country domains.

### Responsible use

Collect public or authorized Jumia data, keep source URLs with downstream analysis, and apply the site terms and applicable laws to the workflow and any personal data encountered.

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text product searches run on Jumia (e.g. 'laptop', 'samsung galaxy', 'air fryer'). Each keyword is searched separately and paginated up to maxPagesPerQuery. Use this for keyword discovery across a market. NOT a URL — to scrape a specific category or product page use startUrls instead.

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

Direct Jumia URLs. A category/listing URL (e.g. https://www.jumia.com.ng/phones-tablets/) is paginated like a search; a product URL (e.g. https://www.jumia.com.ng/...-384422730.html) is scraped as one product. The market is auto-detected from each URL's domain. NOT for keyword search — use searchQueries for that.

## `country` (type: `string`):

Which Jumia country store to search when using searchQueries (startUrls auto-detect their own market). Pick the two-letter market code. Defaults to 'ng' (Nigeria). Ignored for startUrls that already point at a specific Jumia domain.

## `maxResults` (type: `integer`):

Hard cap on the total number of products scraped and billed across all queries and URLs. The run stops once this is reached. Defaults to 50; max 5000. This is the primary cost control — at $0.004/product, 50 products is about $0.20.

## `maxPagesPerQuery` (type: `integer`):

How many listing pages (about 40 products each) to paginate through for each search keyword or category URL before moving on. Defaults to 10; max 50. Lower it to sample only the top results; raise it for deep catalog coverage. Bounded again by maxResults.

## `enrichDetails` (type: `boolean`):

When true, every listing product is followed to its own product page to add specifications, seller, full description, and the image gallery. This is slower and costs an extra $0.004 per enriched product on top of the base price. Leave false for fast price/rating/SKU listing data only.

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

Proxy used for all requests. Jumia is behind Cloudflare and blocks datacenter IPs, so by default this actor uses Apify Residential proxy automatically pinned to the selected market's country (highest success rate). Override only if you have your own residential/custom proxy; datacenter proxies will be blocked.

## `proxyProvider` (type: `string`):

Which proxy backend to use when no custom proxy is set. 'auto' (default) uses Apify Residential and automatically falls back to DataImpulse residential if Cloudflare keeps blocking. 'apify-residential' forces Apify only; 'dataimpulse' forces the DataImpulse fallback. Leave on 'auto' unless debugging blocks.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop",
    "iphone"
  ],
  "startUrls": [
    "https://www.jumia.com.ng/phones-tablets/"
  ],
  "country": "ng",
  "maxResults": 50,
  "maxPagesPerQuery": 2,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "proxyProvider": "auto"
}
```

# Actor output Schema

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

Default dataset containing one structured record per public Jumia product observation.

## `summary` (type: `string`):

Stable terminal outcome with persisted-item counts, charged events, and warnings.

## `runSummary` (type: `string`):

Input coverage, provider route, navigation diagnostics, cost state, and safe errors for the completed run.

# 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 = {
    "searchQueries": [
        "laptop"
    ],
    "country": "ng",
    "maxResults": 50,
    "maxPagesPerQuery": 2,
    "enrichDetails": false,
    "proxyProvider": "auto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/jumia-product-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 = {
    "searchQueries": ["laptop"],
    "country": "ng",
    "maxResults": 50,
    "maxPagesPerQuery": 2,
    "enrichDetails": False,
    "proxyProvider": "auto",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/jumia-product-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 '{
  "searchQueries": [
    "laptop"
  ],
  "country": "ng",
  "maxResults": 50,
  "maxPagesPerQuery": 2,
  "enrichDetails": false,
  "proxyProvider": "auto"
}' |
apify call khadinakbar/jumia-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ngdXfQe1mBhDG1L5q/builds/4mFoeLaYF1wDMhp5T/openapi.json