# Jumia Product Scraper (`khadinakbar/jumia-product-scraper`) Actor

Scrape Jumia products across 11 African markets by keyword, category URL, or product URL.

- **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:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Jumia Product Scraper

Scrape **Jumia** product data across **7 African markets** — by search keyword, category URL, or product URL. Returns clean, structured JSON: name, price, old price, discount %, rating, reviews, brand, SKU, seller, category path, image, and product URL. Optional deep mode adds full specifications, seller, description, and image gallery.

Jumia is protected by sitewide Cloudflare. This actor uses a **Firefox anti-detect engine (Camoufox)** that reliably clears the challenge where plain HTTP scrapers and headless-Chrome scrapers get blocked.

### What you get

| Field | Description |
|-------|-------------|
| `name` | Product title |
| `brand` | Brand name |
| `price` / `priceText` | Current price (number + original text, e.g. `32941` / `"₦ 32,941"`) |
| `oldPrice` / `discountPercent` | Pre-discount price and discount percentage |
| `currency` | ISO currency for the market (NGN, KES, EGP, GHS, …) |
| `rating` / `reviewsCount` | Star rating and number of reviews |
| `sku` | Jumia SKU (stable product identifier) |
| `inStock` | Stock availability |
| `isOfficialStore` / `isExpress` | Official Store badge / Jumia Express flag |
| `coupon` | Active coupon code on the card, if any |
| `categoryPath` | Full category breadcrumb (up to 6 levels) |
| `imageUrl` / `images` | Main image (listing) / gallery (deep mode) |
| `url` | Canonical product URL |
| `seller` / `sellerScore` | Seller name and seller score (deep mode) |
| `specifications` / `keyFeatures` | Spec key-values and feature bullets (deep mode) |
| `description` | Full product description (deep mode) |

### When to use it

- **Price & competitor monitoring** — track competitor SKUs and prices across a Jumia market.
- **Arbitrage / reselling** — find discounted, high-rating products with margin.
- **Catalog & market research** — map a category's brands, price bands, and ratings.
- **AI agents (MCP)** — single keyword/URL in, structured JSON out. Discoverable as `apify--jumia-product-scraper`.

Not for: Jumia order/account data, or non-Jumia stores.

### Pricing (Pay-Per-Event)

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| Product scraped | **$0.004** / product |
| Product detail enriched | **$0.004** / product (only when `enrichDetails = true`) |

So 100 listing products ≈ **$0.40**; 100 fully-enriched products ≈ **$0.80**. `maxResults` caps the spend.

### Input

```json
{
  "searchQueries": ["air fryer", "iphone"],
  "country": "ng",
  "maxResults": 100,
  "maxPagesPerQuery": 10,
  "enrichDetails": false
}
````

Or scrape specific URLs (market auto-detected from the domain):

```json
{
  "startUrls": [
    "https://www.jumia.com.ng/phones-tablets/",
    "https://www.jumia.co.ke/samsung-galaxy-a06-384422730.html"
  ],
  "enrichDetails": true,
  "maxResults": 50
}
```

| Input | Type | Default | Notes |
|-------|------|---------|-------|
| `searchQueries` | string\[] | `["laptop"]` | Keywords to search in the selected market |
| `startUrls` | string\[] | — | Category or product URLs (any Jumia market) |
| `country` | enum | `ng` | Market for `searchQueries`: ng, ke, eg, gh, ma, ci, sn |
| `maxResults` | int | `50` | Total product cap (cost control) |
| `maxPagesPerQuery` | int | `10` | Listing pages per query (≈40 products each) |
| `enrichDetails` | bool | `false` | Visit each product page for specs/seller/description |
| `proxyConfiguration` | proxy | Apify Proxy | Residential, country-pinned gives the best success rate |

### Supported markets

Nigeria (`ng`), Kenya (`ke`), Egypt (`eg`), Ghana (`gh`), Morocco (`ma`), Côte d'Ivoire (`ci`), Senegal (`sn`).

### Output example

```json
{
  "country": "Nigeria",
  "name": "SILVER CREST 8L Extra Large Digital AirFryer",
  "brand": "SILVER CREST",
  "price": 32941,
  "priceText": "₦ 32,941",
  "oldPrice": 44000,
  "discountPercent": 25,
  "currency": "NGN",
  "rating": 4,
  "reviewsCount": 4638,
  "sku": "SI905HA7SA8WLNAFAMZ",
  "inStock": true,
  "isOfficialStore": true,
  "categoryPath": ["Home & Office", "Home & Kitchen", "Kitchen & Dining", "Small Appliances", "Air Fryers"],
  "url": "https://www.jumia.com.ng/silver-crest-8l-extra-large-digital-airfryer-418507707.html",
  "scrapedAt": "2026-06-22T11:54:01.832Z"
}
```

### Usage from code

```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": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["price"], item["currency"])
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('khadinakbar/jumia-product-scraper').call({
    startUrls: ['https://www.jumia.com.ng/phones-tablets/'],
    enrichDetails: true,
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### FAQ

**Why is it browser-based and not instant HTTP?** Jumia sits behind sitewide Cloudflare; plain HTTP and headless-Chrome requests are challenged and blocked. The Camoufox Firefox engine clears the challenge, which is why this actor returns data reliably.

**Does the country / proxy IP affect prices?** No — Jumia localizes by domain (TLD), so each market's store returns its own local currency and catalog regardless of proxy region. A residential, country-pinned proxy still improves the Cloudflare success rate.

**Direct product URL returns null brand/reviews?** In direct product-URL mode some review/brand fields load lazily on the product page. Run via `searchQueries`/category `startUrls` (the default flow) to get brand and review counts from the listing card, optionally with `enrichDetails` for full specs.

**How do I control cost?** `maxResults` is a hard cap on billed products. Leave `enrichDetails` off for the cheapest listing-only data.

### Legal

This actor collects only publicly available data from Jumia listing and product pages. Use it in compliance with Jumia's Terms of Service and applicable laws (including data-protection regulations). You are responsible for how you use the scraped data. This actor does not access private, account, or order data, and is not affiliated with or endorsed by Jumia.

# 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": 10,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "proxyProvider": "auto"
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "searchQueries": [
        "laptop"
    ],
    "country": "ng",
    "maxResults": 50
};

// 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,
}

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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jumia Product Scraper",
        "description": "Scrape Jumia products across 11 African markets by keyword, category URL, or product URL.",
        "version": "0.1",
        "x-build-id": "Rc7Ifsdp7V1HxF1dR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~jumia-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-jumia-product-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/khadinakbar~jumia-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-jumia-product-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/khadinakbar~jumia-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-jumia-product-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": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Category or product URLs",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Jumia market",
                        "enum": [
                            "ng",
                            "ke",
                            "eg",
                            "gh",
                            "ma",
                            "ci",
                            "sn"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "ng"
                    },
                    "maxResults": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "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.",
                        "default": 50
                    },
                    "maxPagesPerQuery": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "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.",
                        "default": 10
                    },
                    "enrichDetails": {
                        "title": "Scrape full product details",
                        "type": "boolean",
                        "description": "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.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "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.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "proxyProvider": {
                        "title": "Proxy provider (advanced)",
                        "enum": [
                            "auto",
                            "apify-residential",
                            "dataimpulse"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "auto"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
