# Carousell Scraper (`parseforge/carousell-scraper`) Actor

Scrape product listings from Carousell, Southeast Asias largest C2C marketplace. Extract titles, prices, descriptions, seller info, images, and engagement metrics from 9 countries. Filter by keyword, condition, price range, and sort order.

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

## Pricing

$25.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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)

## 🛒 Carousell Scraper

Collect product listings from Carousell across 9 countries in Southeast Asia and beyond. Whether you need a Carousell data extractor without coding, want to download Carousell listings to CSV, or monitor competitor prices on Carousell as an API alternative, this tool handles it all. Just enter a keyword and country, and get structured data in minutes.

> **The Carousell Scraper collects product listings with up to 17 data fields per item, covering 9 countries from a single search.**

### ✨ What Does It Do

- 🖼️ **Image URL** - Download main listing photos and full image galleries for product catalogs or visual analysis
- 💰 **Price and currency** - Track pricing trends across 9 countries with local currency support for market research
- 📝 **Title and description** - Analyze product naming patterns and descriptions to optimize your own listings
- 👤 **Seller name and profile** - Identify top sellers and monitor competitor inventory across regions
- 📋 **Category and subcategory** - Map product categories to understand market structure and demand distribution
- 📊 **Like count** - Gauge product popularity and demand signals to find trending items before they sell out

### 🔧 Input

- **Start URL** — paste a direct Carousell search or category page URL to collect exactly what you see on that page
- **Search keyword** — enter a product name like "iphone 15" or "nike shoes" to search across all listings
- **Max items** — control how many listings to collect (free users: up to 100, paid: up to 1,000,000)
- **Country** — choose which market to search: Singapore, Philippines, Malaysia, Hong Kong, Indonesia, Taiwan, Australia, Canada, or New Zealand
- **Condition** — filter by item condition: New, Used, or Any
- **Min price / Max price** — set a price range in local currency to narrow results
- **Sort by** — order results by Most Recent, Price Low to High, or Price High to Low

```json
{
  "keyword": "iphone",
  "country": "sg",
  "maxItems": 10
}
````

### 📊 Output

Each listing includes up to 17 data fields. Download as JSON, CSV, or Excel.

| 🖼️ Image URL | 📝 Title | 🔗 Listing URL |
|---|---|---|
| 🆔 Listing ID | 💰 Price | 💱 Currency |
| ✅ Condition | 📝 Description | 📋 Category |
| 📋 Subcategory | 👤 Seller Name | 👤 Seller Username |
| 🔗 Seller URL | 🌍 Country | 🖼️ All Images |
| 📊 Like Count | 📅 Collected At | |

### 💎 Why Choose the Carousell Scraper?

| Feature | Our Actor | Carousell Scraper (lexis-solutions) |
|---|---|---|
| Multi-country support (9 countries) | ✔️ | ❌ |
| Price range filtering | ✔️ | ❌ |
| Condition filtering (New/Used) | ✔️ | ❌ |
| Sort by price or recency | ✔️ | ❌ |
| Full image gallery extraction | ✔️ | Partial |
| Seller profile URL | ✔️ | ❌ |
| Like count / engagement data | ✔️ | ❌ |
| Category and subcategory fields | ✔️ | ❌ |
| Direct URL input support | ✔️ | ✔️ |
| Keyword search | ✔️ | ✔️ |
| Rental price | $25/month | $29/month |
| Pay per result | N/A | $0.04/result |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up**: [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool**: Search for "Carousell Scraper" in the Apify Store and configure your input
3. **Run It**: Click "Start" and watch your results appear

That's it. No coding, no setup, no complicated configuration. Now you can export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Market researcher** — collect pricing data across all 9 Carousell markets weekly to build a regional secondhand goods price index for investor reports
- 💼 **Reseller** — monitor "iphone" listings filtered by "Like New" condition and price under $800 to find underpriced inventory before competitors do
- 📣 **Brand manager** — track how your products appear on Carousell across Southeast Asia to identify unauthorized sellers and protect pricing

### ❓ FAQ

**🔍 How does it work?**
Enter a keyword and country (or paste a Carousell URL), hit Start, and the scraper collects all matching listings with full details.

**📊 How accurate is the data?**
Data is collected directly from Carousell's live listings. Prices, descriptions, and seller info match exactly what you see on the site.

**📅 Can I schedule automatic runs?**
Yes. Set up a schedule on Apify to run the scraper daily, weekly, or at any interval you need for ongoing price monitoring.

**⚖️ Is it legal to collect Carousell data?**
This tool collects publicly available listing data. It is your responsibility to comply with local laws and Carousell's terms of service.

**🛡️ Will Carousell block me?**
The scraper uses residential proxies and browser fingerprint rotation to handle Carousell's protection automatically. We recommend keeping the default residential proxy setting.

**⚡ How long does a run take?**
Roughly 1-2 minutes for 100 listings. Larger runs (1,000+ items) may take 10-20 minutes depending on the market.

**🌍 Which countries are supported?**
Singapore, Philippines, Malaysia, Hong Kong, Indonesia, Taiwan, Australia, Canada, and New Zealand.

**⚠️ Are there any limits?**
Free users can collect up to 100 results per run. Paid users can collect up to 1,000,000 results per run.

### 🔗 Integrate Carousell Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Carousell or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `keyword` (type: `string`):

Search keyword or product name to find listings on Carousell (e.g. 'iphone 15', 'sofa'). If provided, filters below are applied alongside the keyword search.

## `startUrl` (type: `string`):

Direct URL to a Carousell search or category page. If provided, keyword and filter inputs are ignored.

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

Free users: Limited to 100. Paid users: Optional, max 1,000,000.

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

Country/region to search in. Options: sg (Singapore), ph (Philippines), my (Malaysia), hk (Hong Kong), id (Indonesia), tw (Taiwan), au (Australia), ca (Canada), nz (New Zealand).

## `condition` (type: `string`):

Filter by item condition.

## `priceMin` (type: `integer`):

Minimum price filter (in local currency).

## `priceMax` (type: `integer`):

Maximum price filter (in local currency).

## `sortBy` (type: `string`):

Sort order for search results.

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

Proxy settings. Residential proxies required for Cloudflare bypass.

## Actor input object example

```json
{
  "keyword": "iphone",
  "maxItems": 10,
  "country": "sg",
  "sortBy": "3",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "keyword": "iphone",
    "maxItems": 10,
    "country": "sg",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/carousell-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 = {
    "keyword": "iphone",
    "maxItems": 10,
    "country": "sg",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/carousell-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 '{
  "keyword": "iphone",
  "maxItems": 10,
  "country": "sg",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/carousell-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Carousell Scraper",
        "description": "Scrape product listings from Carousell, Southeast Asias largest C2C marketplace. Extract titles, prices, descriptions, seller info, images, and engagement metrics from 9 countries. Filter by keyword, condition, price range, and sort order.",
        "version": "0.1",
        "x-build-id": "LttC30E7249xnbHSv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~carousell-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-carousell-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~carousell-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-carousell-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~carousell-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-carousell-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": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Search keyword or product name to find listings on Carousell (e.g. 'iphone 15', 'sofa'). If provided, filters below are applied alongside the keyword search."
                    },
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct URL to a Carousell search or category page. If provided, keyword and filter inputs are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 100. Paid users: Optional, max 1,000,000."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "sg",
                            "ph",
                            "my",
                            "hk",
                            "id",
                            "tw",
                            "au",
                            "ca",
                            "nz"
                        ],
                        "type": "string",
                        "description": "Country/region to search in. Options: sg (Singapore), ph (Philippines), my (Malaysia), hk (Hong Kong), id (Indonesia), tw (Taiwan), au (Australia), ca (Canada), nz (New Zealand)."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "new",
                            "used",
                            "unspecified"
                        ],
                        "type": "string",
                        "description": "Filter by item condition."
                    },
                    "priceMin": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter (in local currency)."
                    },
                    "priceMax": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter (in local currency)."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "3",
                            "5",
                            "6"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "3"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies required for Cloudflare bypass."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
