# ChicMe Scraper (`crawlerbros/chicme-scraper`) Actor

Scrape ChicMe.com - search products, browse categories/collections with sorting, list all categories, or fetch full product detail by handle. Prices, sizes, colors, images, stock status. No login, no API key, no proxy required.

- **URL**: https://apify.com/crawlerbros/chicme-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## ChicMe Scraper

Scrape [ChicMe.com](https://www.chicme.com) — a global budget fast-fashion storefront. Search products, browse any category with sorting, list all categories, or fetch full product detail by handle/URL. Get price, discount %, colors, sizes, stock status, images, tags and more. No login, no API key, no proxy required.

### What this actor does

- **Five modes:** `search`, `browseCollection`, `listCollections`, `byHandle`, `relatedProducts`
- **Search** — quick free-text product search (top 10 matches)
- **Browse a category** — paginated, with 8 sort orders (price, newest, best-selling, title, featured)
- **List categories** — discover every category/collection on the storefront, with product counts
- **Lookup by handle/URL** — fetch full detail (all variants, all images, full description) for specific products
- **Related products** — "customers also viewed" recommendations for any product handle (up to 10 per handle)
- **Search suggestions** — every `search` run also returns related search terms and matching categories for the query, at no extra cost
- **Category info** — every `browseCollection` run also returns the category's own total product count, description and image, at no extra cost
- **Filters:** price range, in-stock only, on-sale only, minimum discount %, color, size, product type, tags
- **Empty fields are omitted**

### Output per product

- `productId`, `title`, `handle`, `productUrl`
- `vendor`, `productType`, `description`, `tags[]`
- `price`, `compareAtPrice`, `discountPercent`, `currency` (USD)
- `inStock` (search, browseCollection, relatedProducts — omitted for byHandle, since ChicMe's single-product detail endpoint doesn't expose stock status)
- `variants[]` — each with `variantId`, `title`, `sku`, `color`, `size`, `price`, `compareAtPrice`, `inStock` (byHandle omits per-variant `inStock` too, same reason), `imageUrl`, `weightGrams` (shipping weight in grams)
- `availableColors[]`, `availableSizes[]`
- `imageUrl` (primary), `images[]` (up to 10)
- `publishedAt`, `createdAt`, `updatedAt`
- `sourceMode`, `recordType: "product"`, `scrapedAt`
- `relatedToHandle` (mode=relatedProducts only) — the product handle this recommendation was fetched for

### Output per category (mode=listCollections)

- `collectionId`, `title`, `handle`, `collectionUrl`
- `description`, `productsCount`, `imageUrl`
- `publishedAt`, `updatedAt`
- `recordType: "collection"`, `scrapedAt`

### Search suggestions record (mode=search, one per run)

Alongside product results, every `search` run pushes one extra record with related search-term completions and matching categories for the query — useful for discovering better keywords or category handles, and returned even when the query itself has 0 product matches.

- `searchQuery` — the query you searched for
- `relatedSearchTerms[]` — ChicMe's own predictive "did you mean" / related terms for the query
- `matchedCollections[]` — categories matching the query, each with `title`, `handle`, `collectionUrl`
- `recordType: "searchSuggestions"`, `scrapedAt`

### Category info record (mode=browseCollection, one per run)

Every `browseCollection` run also pushes one extra record describing the category itself — its own title/description and the **total** number of products it contains storewide (`productsCount`), so you can tell at a glance how many products were emitted vs. how many exist in total.

- `collectionId`, `title`, `handle`, `collectionUrl`
- `description`, `productsCount`, `imageUrl`
- `publishedAt`, `updatedAt`
- `recordType: "collectionInfo"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseCollection` / `listCollections` / `byHandle` / `relatedProducts` |
| `searchQuery` | string | `summer dress` | Free-text query (mode=search) |
| `collectionHandle` | select | `dresses` | Common category (mode=browseCollection) |
| `customCollectionHandle` | string | – | Overrides the dropdown with any handle/URL |
| `sortBy` | select | `best-selling` | Sort order within the category |
| `productHandles` | array | – | Product handles/URLs (mode=byHandle looks them up directly; mode=relatedProducts fetches recommendations for each) |
| `priceMin` | number | – | Drop products cheaper than this (USD) |
| `priceMax` | number | – | Drop products pricier than this (USD) |
| `inStockOnly` | bool | `false` | Only emit products with an available variant. Not usable with mode=byHandle — ChicMe's single-product detail endpoint doesn't report stock status, so this filter drops everything in that mode |
| `onSaleOnly` | bool | `false` | Only emit products genuinely marked down (`discountPercent` > 0) |
| `discountMinPercent` | number | – | Only emit products marked down by at least this % (e.g. `20`) |
| `color` | string | – | Only emit products with a matching variant color (partial match, e.g. `black`) |
| `size` | string | – | Only emit products with a matching available size (exact match, e.g. `M`) |
| `productType` | select | – | Common garment style/cut, e.g. `Bodycon`, `A Line`, `Blazer` (not `Dress`, which is a category, not a style type) |
| `productTypeContains` | string | – | Free-text override for `productType` above (partial match) — use for a style not in the dropdown |
| `tagsInclude` | array | – | Only emit products carrying at least one of these tags |
| `maxItems` | int | `50` | Hard cap (1–1000) |

#### Example: search

```json
{
  "mode": "search",
  "searchQuery": "summer dress"
}
```

#### Example: browse a category, cheapest first

```json
{
  "mode": "browseCollection",
  "collectionHandle": "bodycon-dresses",
  "sortBy": "price-ascending",
  "priceMax": 30,
  "inStockOnly": true,
  "maxItems": 100
}
```

#### Example: browse a category, filtered by color/size/tags

```json
{
  "mode": "browseCollection",
  "collectionHandle": "dresses",
  "color": "black",
  "size": "M",
  "productTypeContains": "bodycon",
  "tagsInclude": ["Party"],
  "maxItems": 50
}
```

#### Example: discover every category

```json
{
  "mode": "listCollections",
  "maxItems": 300
}
```

#### Example: full detail for specific products

```json
{
  "mode": "byHandle",
  "productHandles": [
    "floral-print-u-neck-long-sleeve-ribbed-tee-slim-fit-layering-top",
    "https://www.chicme.com/products/zipper-knee-high-thin-heel-boots-pointed-toe-long-sexy-stiletto-heel"
  ]
}
```

#### Example: related products for a specific item

```json
{
  "mode": "relatedProducts",
  "productHandles": [
    "floral-print-u-neck-long-sleeve-ribbed-tee-slim-fit-layering-top"
  ],
  "maxItems": 10
}
```

### Use cases

- **Price monitoring** — track a category for price drops or restocks
- **Trend research** — see what's newly listed or best-selling in a category
- **Catalog aggregation** — pull ChicMe's product catalog into a comparison feed
- **Assortment analysis** — compare color/size availability across a category
- **Content/affiliate sites** — build "best deals" or "new arrivals" roundups

### FAQ

**Do I need a ChicMe account or API key?**  No. The actor reads ChicMe's public storefront data — no login, cookies, or API key are required.

**Why is `search` capped at ~10 results?**  ChicMe's quick-search endpoint is a predictive/typeahead search and caps at 10 matches per query, regardless of how high `maxItems` is set. For deeper, paginated results use `browseCollection` instead — it returns the full category, sorted however you like.

**How do I find more category handles?**  Run `mode=listCollections` first (optionally with a high `maxItems`) to get every category's `handle`, `title`, and `productsCount`, then feed a `handle` into `customCollectionHandle`.

**What currency are prices in?**  USD.

**What does `discountPercent` mean?**  The percentage off the list price (`compareAtPrice`), only included when the item is genuinely marked down.

**Why do some products have no `variants`?**  `search` results are automatically enriched with a full product lookup so colors/sizes/variants match `browseCollection` and `byHandle`. A product only omits `variants` if it genuinely has no variant data on ChicMe (rare, single-SKU listings).

**Can I filter by color, size, or tags?**  Yes — `color` and `productType`/`productTypeContains` do a case-insensitive partial match, `size` is an exact case-insensitive match, and `tagsInclude` matches if the product has any of the given tags. All four work identically across `search`, `browseCollection`, and `byHandle`.

**What's the difference between `productType` and `productTypeContains`?**  `productType` is a dropdown of ChicMe's common garment styles (Bodycon, A Line, Blazer, Jumpsuit, etc.). `productTypeContains` is a free-text field that overrides the dropdown — use it for a style not yet in the list, or a broader partial match.

**Can I get only discounted / on-sale items?**  Set `onSaleOnly: true` to only emit products with a genuine markdown (`discountPercent` > 0), or set `discountMinPercent` (e.g. `30`) for a minimum markdown threshold, or point `collectionHandle`/`customCollectionHandle` at ChicMe's own sale categories (e.g. `clearance-sale`, `last-chance-deals`) and combine all three for the deepest discounts.

**How fresh is the data?**  Real-time — every request reads ChicMe's live storefront.

**What does `mode=relatedProducts` return?**  The same "customers also viewed" recommendations ChicMe shows on a product page, for each handle you supply. This is capped at 10 recommendations per handle by ChicMe itself, regardless of `maxItems`.

**What's the `searchSuggestions` record I see in `mode=search` output?**  One extra record per run (not counted against `maxItems`) with related search terms and matching categories for your query — handy for widening a search or jumping straight to `browseCollection` with a discovered category handle.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text product search (mode=search). ChicMe's quick-search returns up to 10 top matches.

## `collectionHandle` (type: `string`):

Pick a common ChicMe category. For a category not listed, use "Custom category handle" below instead.

## `customCollectionHandle` (type: `string`):

Overrides the dropdown above. Paste any ChicMe collection handle or full collection URL, e.g. `sleep-to-lounge` or `https://www.chicme.com/collections/sleep-to-lounge`. Use mode=listCollections to discover valid handles.

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

How to order products within the category.

## `productHandles` (type: `array`):

ChicMe product handles or full product URLs, e.g. `floral-print-u-neck-long-sleeve-ribbed-tee-slim-fit-layering-top` or `https://www.chicme.com/products/<handle>`. For mode=byHandle these are looked up directly; for mode=relatedProducts each handle's "customers also viewed" recommendations (up to 10 per handle) are fetched instead.

## `priceMin` (type: `number`):

Drop products cheaper than this.

## `priceMax` (type: `number`):

Drop products more expensive than this.

## `inStockOnly` (type: `boolean`):

Only emit products with at least one available variant. Not usable with mode=byHandle: ChicMe's single-product detail endpoint doesn't report stock status, so this drops everything in that mode.

## `onSaleOnly` (type: `boolean`):

Only emit products that are genuinely marked down (have a `discountPercent` above 0).

## `discountMinPercent` (type: `number`):

Only emit products marked down by at least this percentage, e.g. `20` for 20% off or more. Implies on-sale (products without a genuine markdown are dropped).

## `color` (type: `string`):

Only emit products with a variant color matching this text (case-insensitive, partial match), e.g. `black` or `floral print`.

## `size` (type: `string`):

Only emit products with an available size exactly matching this (case-insensitive), e.g. `M`, `XL`, `2XL`.

## `productType` (type: `string`):

Pick a common ChicMe garment style/cut. For a style not listed, use "Product type contains" below instead.

## `productTypeContains` (type: `string`):

Free-text override for the dropdown above (case-insensitive, partial match). Only emit products whose type matches this text, e.g. `Bodycon`, `A Line`, `Blazer`, `Jeans`, `Cardigan` (not `Dress` or `Sweater`, which are category names, not style types). Takes priority over "Product type" above when both are set.

## `tagsInclude` (type: `array`):

Only emit products that carry at least one of these tags (case-insensitive), e.g. `Floral`, `Fall`, `Party`. Tags vary widely per product — use mode=search or mode=browseCollection first to discover typical tags.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "summer dress",
  "collectionHandle": "dresses",
  "sortBy": "best-selling",
  "productHandles": [],
  "inStockOnly": false,
  "onSaleOnly": false,
  "tagsInclude": [],
  "maxItems": 50
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped ChicMe records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "summer dress",
    "collectionHandle": "dresses",
    "sortBy": "best-selling",
    "productHandles": [],
    "inStockOnly": false,
    "onSaleOnly": false,
    "tagsInclude": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/chicme-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 = {
    "mode": "search",
    "searchQuery": "summer dress",
    "collectionHandle": "dresses",
    "sortBy": "best-selling",
    "productHandles": [],
    "inStockOnly": False,
    "onSaleOnly": False,
    "tagsInclude": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/chicme-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQuery": "summer dress",
  "collectionHandle": "dresses",
  "sortBy": "best-selling",
  "productHandles": [],
  "inStockOnly": false,
  "onSaleOnly": false,
  "tagsInclude": [],
  "maxItems": 50
}' |
apify call crawlerbros/chicme-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/chicme-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GhAi4c9yVRqxNXHyB/builds/dpkrb3mjDLHY787fU/openapi.json