# Noon MENA Product Scraper (`parseforge/noon-mena-scraper`) Actor

Sweep Noon storefronts in the Middle East and pull product listings by search query. Each record returns image URL, title, price, product URL, SKU, brand, rating, seller, category, condition, and EAN. Pick the country marketplace for pricing intelligence and competitor monitoring.

- **URL**: https://apify.com/parseforge/noon-mena-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛍️ Noon MENA Product Scraper

> 🚀 **Export Noon MENA product listings in seconds. Direct from https://www.noon.com to a structured dataset ready for any spreadsheet, database, or BI tool.**

> 🕒 **Last updated** 2026-06-05 · **📊 9 fields** per record · Public REST API source · Real time results

The Noon MENA Product Scraper turns the [https://www.noon.com](https://www.noon.com) public storefront into a clean structured dataset. Enter a search query, choose how many items you want, and get back a flat table with title, price, image, sku, brand, rating, seller, country, url.

Built for analysts, marketplace operators, and product researchers who need Noon MENA product listings without writing a single line of client code.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 📊 Market analysts | Track pricing and stock across the catalog |
| 🛒 Marketplace operators | Benchmark competitor listings |
| 💼 Procurement teams | Sourcing and supplier discovery |
| 🤖 ML engineers | Build product datasets for training |
| 📰 Journalists | Snapshot listings for stories |
| 👩‍💻 Developers | Mirror public catalog data into your own database |

### 📋 What the Noon MENA Scraper does

- Hits the public https://www.noon.com search endpoint with the query you supply.
- Parses the REST API response and flattens each result into one row.
- Normalizes field names so they import cleanly into any spreadsheet or warehouse.
- Skips duplicates and short circuits when the upstream returns no further results.
- Surfaces upstream errors as a single diagnostic record instead of crashing.
- Exports to dataset in every format Apify supports.

> 💡 **Why it matters** Direct access to https://www.noon.com catalog data without writing scraping infrastructure, rotating proxies, or maintaining selectors. One run, one clean table.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>query</code></td><td>string</td><td>No</td><td>Search term entered into Noon search. Trimmed before use.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users 10. Paid users up to 1,000,000. Prefill 10.</td></tr>
<tr><td><code>country</code></td><td>string</td><td>No</td><td>Noon storefront to query. Determines currency and shipping availability.</td></tr>
</table>

**Example 1 standard search**
```json
{
  "query": "headphones",
  "maxItems": 25
}
````

**Example 2 small preview**

```json
{
  "query": "headphones",
  "maxItems": 5
}
```

> ⚠️ **Good to Know** This actor only reads publicly available pages from https://www.noon.com. No login or API key is required.

### 📊 Output

Each record is a flat object. `imageUrl` is always first, `error` is always last.

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Main product image URL. |
| 🔹 `title` | string | title from the source listing. |
| 🔹 `price` | string | price from the source listing. |
| 🔹 `image` | string | image from the source listing. |
| 🔹 `sku` | string | sku from the source listing. |
| 🔹 `brand` | string | brand from the source listing. |
| 🔹 `rating` | string | rating from the source listing. |
| 🔹 `seller` | string | seller from the source listing. |
| 🔹 `country` | string | country from the source listing. |
| 🔹 `url` | string | url from the source listing. |
| 🕒 `scrapedAt` | string | When this row was fetched. |
| ❌ `error` | string | Set only if the upstream response failed. |

**Sample record**

```json
{
  "imageUrl": "https://...",
  "title": "Sony WH-1000XM5 Headphones",
  "price": 1499,
  "brand": "Sony",
  "rating": 4.7,
  "seller": "Sony Official",
  "country": "uae",
  "url": "https://www.noon.com",
  "scrapedAt": "2026-06-05T13:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🆓 | Works without a login, account, or API key. |
| 🧹 | Cleans up upstream field names into snake friendly columns. |
| 🔢 | Auto casts numeric strings to real numbers for spreadsheet imports. |
| 🛟 | Surfaces upstream errors as a single diagnostic record rather than crashing. |
| 🔌 | One field input. Run, download, done. |
| 💾 | Push to dataset and pull any tabular format you need. |

### 📈 How it compares to alternatives

| Approach | Setup time | Clean keys? | Numeric casting? | Maintenance? |
|---|---|---|---|---|
| Roll your own scraper | hours | ❌ | ❌ | ongoing |
| Generic web scraper | minutes plus tuning | partial | ❌ | ongoing |
| **This Actor** | 5 seconds | ✅ | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Enter a search term in `query`.
3. Set `maxItems` to the number of records you want.
4. Click **Start**. Within seconds your dataset is ready to download.

### 💼 Business use cases

**📊 Pricing intelligence.** Track how prices move across the Noon MENA catalog by scheduling a daily run on your top SKUs.

**💼 Competitive benchmarking.** Compare your own catalog against Noon MENA to spot gaps and overlaps.

**📰 Market reporting.** Snapshot listings on a fixed cadence to support newsroom or research stories.

**🤖 ML feature engineering.** Build clean catalog datasets for recommendation, search, or pricing models.

### 🔌 Automating Noon MENA Scraper

- **Make and Zapier** trigger this actor on schedule, push results to Airtable, Slack, or your CRM.
- **Cron schedule** native Apify scheduler runs your job daily, weekly, or hourly.
- **Webhooks** get a POST the moment a run finishes.
- **Warehouse pipes** stream straight into BigQuery, Snowflake, or Postgres.

### 🌟 Beyond business use cases

**🎓 Education.** Teach data engineering or e commerce analytics with real catalog data.

**🧪 Personal research.** Track price history of items you care about without manual checking.

**🤝 Non profit and open data.** Build transparent dashboards of public catalog pricing.

**🧰 Tinkering and prototyping.** Spin up a product feed in seconds to test a new shop UI or data app.

### 🤖 Ask an AI assistant about this scraper

Paste this README into ChatGPT, Claude, or any AI assistant and ask it to map your workflow to the actor inputs. The schema, examples, and field list above contain everything an LLM needs to design a working pipeline.

### ❓ Frequently Asked Questions

**❓ Do I need an account or API key?** No. https://www.noon.com pages are public and this actor reads only those.

**❓ How many results can I get?** Free users 10. Paid users up to 1,000,000 per run.

**❓ Are values cast to numbers?** Yes. Numeric fields are typed correctly so spreadsheets and pandas treat them as numbers.

**❓ How do you handle blocks or errors?** Upstream errors are pushed as a single diagnostic record instead of crashing the run.

**❓ Can I schedule runs?** Yes, use Apify scheduler or hook this actor into Make, Zapier, or cron.

**❓ Is this scraping or an API?** It is a public source read. We normalize whatever https://www.noon.com returns publicly.

**❓ Will the schema change?** Core fields are stable. Source specific extras are passed through when present.

**❓ Can I filter by category or brand?** Use the search query field to scope your run. Additional filters can be added on request.

**❓ What formats can I download?** Every tabular format Apify supports straight from the dataset UI.

**❓ Is the data refreshed live?** Yes. Every run hits https://www.noon.com fresh.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST or webhook endpoint. Trigger runs from a calendar event, a form submission, a cron job, or pipe results straight into BigQuery, Snowflake, or a Postgres warehouse.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Public market data, FX and crypto quotes. |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Yahoo Finance Scraper](https://apify.com/parseforge) | Equities, funds, indices. |
| [ParseForge NBA Stats Scraper](https://apify.com/parseforge/nba-stats-scraper) | Player and team stats from NBA. |

> 💡 **Pro Tip** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production grade scrapers across business intelligence, real estate, e commerce, sports, finance, and public records.

***

**Disclaimer.** This actor reads only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third party services referenced. Users are responsible for complying with the target site terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `query` (type: `string`):

Search term entered into Noon search. Trimmed before use.

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

Free users limited to 10 items preview. Paid users optional up to 1,000,000.

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

Noon storefront to query. Determines currency and shipping availability.

## Actor input object example

```json
{
  "query": "headphones",
  "maxItems": 10,
  "country": "uae"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "query": "headphones",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/noon-mena-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 = {
    "query": "headphones",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/noon-mena-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 '{
  "query": "headphones",
  "maxItems": 10
}' |
apify call parseforge/noon-mena-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Noon MENA Product Scraper",
        "description": "Sweep Noon storefronts in the Middle East and pull product listings by search query. Each record returns image URL, title, price, product URL, SKU, brand, rating, seller, category, condition, and EAN. Pick the country marketplace for pricing intelligence and competitor monitoring.",
        "version": "0.1",
        "x-build-id": "1b9n7iZSBvfr2JC1z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~noon-mena-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-noon-mena-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/parseforge~noon-mena-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-noon-mena-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/parseforge~noon-mena-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-noon-mena-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search term entered into Noon search. Trimmed before use."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users limited to 10 items preview. Paid users optional up to 1,000,000."
                    },
                    "country": {
                        "title": "Country storefront",
                        "enum": [
                            "uae",
                            "saudi",
                            "egypt"
                        ],
                        "type": "string",
                        "description": "Noon storefront to query. Determines currency and shipping availability.",
                        "default": "uae"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
