# Jumia Scraper (`automation-lab/jumia-products-sellers-scraper`) Actor

Search eight African Jumia storefronts and extract public products, local prices, discounts, availability, ratings, sellers, country, and source URLs.

- **URL**: https://apify.com/automation-lab/jumia-products-sellers-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.16 / 1,000 item extracteds

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

Extract public Jumia product and seller data across African storefronts for catalog comparison, price monitoring, assortment research, and data pipelines.

The Actor searches Jumia Nigeria, Kenya, Ghana, Uganda, Egypt, Morocco, Côte d'Ivoire, and Senegal. It returns normalized product identity, local prices, discounts, availability, ratings, public seller details, country, and source URLs.

### What does the Jumia Scraper do?

Jumia Scraper turns public marketplace pages into structured dataset rows.

You can:

- search one or more product terms across selected countries;
- scrape a specific public product, category, or search URL;
- compare prices in each storefront's local currency;
- enrich listings with seller name, seller URL, and availability;
- schedule recurring runs to observe catalog changes;
- export results as JSON, CSV, Excel, XML, or RSS through Apify.

The Actor uses country-matched residential sessions because Jumia's public storefronts can challenge ordinary server traffic. It starts with efficient HTTP extraction and uses a browser only as a bounded fallback.

### Who is it for?

**Marketplace analysts** can compare assortment and price positioning across countries.

**Retail and brand teams** can inspect public product availability, discounts, ratings, and seller presence.

**Data engineers** can feed normalized Jumia catalog rows into warehouses, dashboards, or monitoring jobs.

**Researchers** can build snapshots of public marketplace listings without collecting customer or account data.

**Seller operations teams** can find public seller identities attached to specific product offers.

### Supported Jumia countries

| Code | Storefront | Currency |
| --- | --- | --- |
| `NG` | Nigeria | NGN |
| `KE` | Kenya | KES |
| `GH` | Ghana | GHS |
| `UG` | Uganda | UGX |
| `EG` | Egypt | EGP |
| `MA` | Morocco | MAD |
| `CI` | Côte d'Ivoire | XOF |
| `SN` | Senegal | XOF |

For keyword searches, the Actor applies every query to every selected country. For explicit URLs, it detects the country from the domain.

### What data can I extract?

| Field | Meaning |
| --- | --- |
| `productId` | Stable product ID parsed from the URL, with SKU fallback |
| `sku` | Jumia product SKU |
| `title` | Public product title |
| `brand` | Brand when shown |
| `category` | Category or category path |
| `price` | Current price in local storefront currency |
| `oldPrice` | Previous/list price when displayed |
| `currency` | ISO currency code |
| `discountPercent` | Displayed discount |
| `availability` | Structured availability such as `InStock` |
| `rating` | Average public rating |
| `reviewCount` | Public rating/review count |
| `sellerId` | Public Jumia seller ID |
| `sellerName` | Public seller name |
| `sellerUrl` | Public seller page URL |
| `imageUrl` | Primary product image |
| `country`, `countryName` | Storefront geography |
| `sourceUrl` | Public product URL |
| `searchQuery` | Query that discovered the item |
| `scrapedAt` | UTC collection time |

Seller and authoritative availability fields require `includeSellerDetails: true`.

### Getting started

1. Open the Actor input in Apify Console.
2. Enter one or more product searches in **Search queries**.
3. Select the Jumia countries to inspect.
4. Choose a result limit and page limit.
5. Keep seller enrichment enabled when you need seller and stock fields.
6. Click **Start**.
7. Open the **Jumia products** dataset view or export it in your preferred format.

A small first run is recommended before scaling a recurring workflow.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | string\[] | — | Product terms searched in every selected country |
| `countries` | string\[] | `["NG"]` | Supported country codes |
| `startUrls` | URL\[] | — | Public Jumia product, category, or search URLs |
| `maxItems` | integer | `50` | Global unique-product limit, 1–5,000 |
| `maxPagesPerQuery` | integer | `2` | Pages inspected per query and country, 1–50 |
| `includeSellerDetails` | boolean | `true` | Enrich seller, availability, and product-detail fields |

Provide at least one query or start URL. Unsupported domains and malformed URLs fail clearly instead of being silently ignored.

### Example: search Jumia Nigeria

```json
{
  "queries": ["iphone"],
  "countries": ["NG"],
  "maxItems": 5,
  "maxPagesPerQuery": 1,
  "includeSellerDetails": false
}
```

This fast listing workflow is useful for a current price and assortment snapshot.

### Example: compare countries and sellers

```json
{
  "queries": ["laptop"],
  "countries": ["NG", "KE", "GH"],
  "maxItems": 30,
  "maxPagesPerQuery": 2,
  "includeSellerDetails": true
}
```

Schedule the same input daily or weekly and compare datasets by `sku`, `country`, `price`, `availability`, and `sellerName`.

### Example output

```json
{
  "productId": "123456789",
  "sku": "AP044EA000000NAFAMZ",
  "title": "Example smartphone 128 GB",
  "brand": "Example Brand",
  "category": "Phones & Tablets > Smartphones",
  "price": 74999,
  "oldPrice": 89999,
  "currency": "NGN",
  "discountPercent": 17,
  "availability": "InStock",
  "rating": 4.3,
  "reviewCount": 128,
  "sellerId": "100001",
  "sellerName": "Example Store",
  "sellerUrl": "https://www.jumia.com.ng/example-store/",
  "imageUrl": "https://ng.jumia.is/unsafe/fit-in/300x300/product/example.jpg",
  "country": "NG",
  "countryName": "Nigeria",
  "sourceUrl": "https://www.jumia.com.ng/example-smartphone-123456789.html",
  "searchQuery": "smartphone",
  "scrapedAt": "2026-07-31T12:00:00.000Z"
}
```

Nullable fields may be `null` when Jumia does not expose them on the tested page.

### How much does it cost to monitor Jumia products?

The Actor uses pay per event pricing:

- one `start` event per run;
- one `item` event for each product saved to the dataset.

The current source configuration starts at a **$0.005 run fee** and the BRONZE tier is **$0.0036 per saved product**. Higher account tiers receive lower item prices. Apify displays the price applicable to your plan before you start the run.

At the BRONZE item rate, illustrative Actor charges are:

| Products | Actor charge formula |
| ---: | --- |
| 10 | start fee + 10 × applicable item rate |
| 100 | start fee + 100 × applicable item rate |
| 1,000 | start fee + 1,000 × applicable item rate |

Residential proxy and platform usage can be billed separately according to your Apify plan. Actual total cost depends on selected countries, detail enrichment, pages, retries, and proxy transfer. Use a small representative run to estimate a recurring schedule.

### Catalog monitoring workflow

For repeat monitoring:

1. Choose stable queries and countries.
2. Keep the same input and schedule interval.
3. Export each dataset or retrieve it through the API.
4. Join records on `country` plus `sku` or `productId`.
5. Compare `price`, `oldPrice`, `discountPercent`, `availability`, and `sellerName`.
6. Alert only on changes meaningful to your business.

The Actor produces snapshots. It does not maintain historical state or send alerts itself.

### Integrations and exports

Use Apify integrations to send results to:

- Google Sheets;
- webhooks and automation platforms;
- cloud storage;
- data warehouses;
- custom JavaScript or Python pipelines.

Dataset exports support JSON, JSONL, CSV, Excel, XML, and RSS.

### Run with the Apify API

Replace `YOUR_APIFY_TOKEN` with a token stored securely.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~jumia-products-sellers-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["laptop"],"countries":["NG","KE"],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jumia-products-sellers-scraper').call({
  queries: ['laptop'],
  countries: ['NG', 'KE'],
  maxItems: 20,
  includeSellerDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jumia-products-sellers-scraper').call(run_input={
    'queries': ['laptop'],
    'countries': ['NG', 'KE'],
    'maxItems': 20,
    'includeSellerDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Jumia Scraper with MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/jumia-products-sellers-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use the equivalent MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/jumia-products-sellers-scraper"
    }
  }
}
```

Example prompts:

- “Search Jumia Nigeria and Kenya for laptops and return 20 enriched products.”
- “Extract the current price, availability, and seller from this Jumia product URL.”
- “Run my saved Jumia input and summarize price differences by country.”

### Reliability and retry behavior

Jumia may serve Cloudflare challenges to automated traffic. The Actor uses:

- country-matched residential proxy geography;
- sticky proxy and cookie sessions within each country;
- bounded session rotation;
- browser fallback only after a recognized HTTP challenge;
- three maximum attempts before failing the affected run.

A challenge page is never returned as a successful empty dataset. Terminal upstream failures propagate as failed runs so schedules and integrations can detect them.

### Limits and troubleshooting

**Why did my run use more time with seller enrichment?**

Each product page must be opened to obtain structured seller and availability data. Disable `includeSellerDetails` for listing-only price monitoring.

**Why did the run fail with a proxy message?**

The Actor requires access to Apify residential proxies. Confirm that the account running it can use residential proxy groups.

**Why are some fields null?**

Jumia does not expose every field for every listing. Seller fields are also null when detail enrichment is disabled or a detail page cannot be enriched.

**Why are prices not directly comparable between countries?**

Results preserve local storefront currencies. Convert currencies in your downstream workflow using a rate appropriate for your analysis date.

**Can I scrape a customer account or checkout?**

No. The Actor is limited to public catalog, product, category, search, and seller surfaces.

### Legality and responsible use

Scrape only public information you are permitted to collect. Follow applicable laws, Jumia's terms, robots guidance, contractual obligations, and rate limits. Do not use the Actor to collect personal customer data, access accounts, bypass authorization, or make purchasing decisions without independent verification.

Marketplace content can change after collection. Verify critical price, availability, and seller information on the source page.

### Related automation-lab Actors

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) for Amazon catalog research.
- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) for shopping-search comparisons.
- [Jumia Scraper](https://apify.com/automation-lab/jumia-products-sellers-scraper) for the multi-country workflow described here.

### FAQ

**Does this Actor support Jumia Kenya, Ghana, and Egypt?**

Yes. Select `KE`, `GH`, or `EG`, alone or with other supported country codes.

**Can I start from a product URL?**

Yes. Add any supported public Jumia product URL to `startUrls`; the Actor detects its country and extracts structured product and seller details.

**Does it download product images?**

No. It returns the public primary image URL without downloading image binaries, reducing transfer and storage.

**Does it track historical changes?**

It returns current snapshots. Schedule runs and compare datasets externally to build history.

**Are duplicates removed?**

Yes. Product URLs are deduplicated within each run before charging and saving.

**Will a no-result query fail?**

A genuine no-result page completes without invented records. Challenge or unrecognized page shapes fail instead of masquerading as no results.

### Support

If a public Jumia page that should be supported stops producing expected data, include the run URL, country code, input mode, and affected source URL when reporting the issue. Do not include credentials or customer data.

# Actor input Schema

## `queries` (type: `array`):

Product searches to run in every selected country, such as iphone, laptop, or running shoes.

## `countries` (type: `array`):

Country storefronts to search. Each storefront uses a sticky residential proxy in the matching country.

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

Optional product, category, or search URLs from a supported Jumia country domain. URL country is detected automatically.

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

Maximum number of unique product records saved across all queries, URLs, countries, and pages.

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

Maximum catalog result pages to inspect for each query and country.

## `includeSellerDetails` (type: `boolean`):

Open each product page to include seller name, seller URL, availability, and authoritative product price. Disable for faster listing-only monitoring.

## Actor input object example

```json
{
  "queries": [
    "iphone"
  ],
  "countries": [
    "NG",
    "KE"
  ],
  "startUrls": [],
  "maxItems": 10,
  "maxPagesPerQuery": 2,
  "includeSellerDetails": true
}
```

# Actor output Schema

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

Default dataset with all scraped product records.

# 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 = {
    "queries": [
        "iphone"
    ],
    "countries": [
        "NG",
        "KE"
    ],
    "startUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jumia-products-sellers-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 = {
    "queries": ["iphone"],
    "countries": [
        "NG",
        "KE",
    ],
    "startUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jumia-products-sellers-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 '{
  "queries": [
    "iphone"
  ],
  "countries": [
    "NG",
    "KE"
  ],
  "startUrls": [],
  "maxItems": 10
}' |
apify call automation-lab/jumia-products-sellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/gTKgrd4eLyjwfBxCA/builds/phtUReVmqgbyocYWc/openapi.json