# Quince.com Product Scraper - Prices, Discounts, Reviews & More (`techforce.global/quince-scraper`) Actor

Search products and walk away with selling prices, retail prices, discounts, hero images, and the latest customer reviews for every product, ready to drop into your spreadsheet, dashboard, or BI tool. The Quince.com Product Scraper turns catalog into clean, structured product data in minutes.

- **URL**: https://apify.com/techforce.global/quince-scraper.md
- **Developed by:** [Techforce Global](https://apify.com/techforce.global) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 7 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $15.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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Quince.com Product Scraper — Prices, Discounts, Reviews & Images at Scale

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?logo=apify)](https://apify.com/techforce.global/quince-scraper)
[![MCP Ready](https://img.shields.io/badge/MCP-Compatible-blue?logo=anthropic)](https://mcp.apify.com?tools=techforce.global/quince-scraper)
[![Pricing](https://img.shields.io/badge/Pricing-from%20$15.00%20/%201k%20results-green)](https://apify.com/techforce.global/quince-scraper)
[![Target](https://img.shields.io/badge/Target-Quince.com-red)](https://www.quince.com)

> Turns Quince's catalog into clean, structured product data: selling price, strike-through retail price, a pre-computed discount percentage, primary-color hero images, the 5 most recent customer reviews, average rating, and review count. Discover products three ways — keyword search, a 323-entry category dropdown, or a list of product URLs — and deliver results straight into Notion, Slack, Google Sheets, Airtable, or any MCP-compatible AI agent pipeline.

***

#### Manual price-checking / DIY script vs. Quince Product Scraper Actor

Quince publishes no public product API, and its listing and product pages render from an embedded Next.js SSR payload behind Cloudflare — the two things that break a naive scraper:

| Feature / Capability | Manual checking or a DIY scraper | Quince Product Scraper Actor (Apify) |
| :--- | :--- | :--- |
| **Public product API** | ❌ None offered by Quince | ✅ Not needed — reads the page's own SSR payload |
| **Bot mitigation** | ❌ Plain `requests` gets a Cloudflare challenge page | ✅ Chrome TLS impersonation + Apify residential proxy wiring |
| **Keyword search** | ⚠️ Search results render client-side, so HTML scraping returns nothing | ✅ Queries Quince's Algolia index directly |
| **Discount maths** | ❌ You compute it yourself per SKU | ✅ `discount` is calculated for you (`$39.90` was `$79` → `49.5%`) |
| **Image noise** | ⚠️ Colour-variant and recommendation images bleed in | ✅ Primary-colour hero images only |
| **Reviewer privacy** | ❌ Raw reviewer emails end up in your file | ✅ Email-shaped author handles are masked automatically |
| **AI agent / MCP native** | ❌ Requires a custom tool wrapper | ✅ Native MCP tool **and** pushes results into your own MCP connectors |
| **Cost model** | Your dev time + infra | Pay-per-result, from $15.00 per 1,000 products |

***

### 🤖 AI Discovery & MCP Metadata

Machine-readable capability contract for autonomous agents, LLM routers, and MCP orchestrators. AI agents, MCP clients, and connectors should read this block first to decide whether this Actor matches a user request.

```yaml
ai_discovery:
  slug: "techforce.global/quince-scraper"
  one_line: "Extract Quince.com product data (prices, discount %, hero images, latest reviews, ratings) by keyword search, category slug, or product URL list, with optional delivery to an MCP connector."
  primary_purpose: "extract"
  secondary_purpose: "deliver"
  entity: "Quince.com products"
  supported_platforms:
    - "quince.com"
  supported_tasks:
    - "search-products-by-keyword"
    - "browse-products-by-category"
    - "scrape-specific-product-urls"
    - "extract-selling-and-retail-price"
    - "compute-discount-percentage"
    - "extract-latest-reviews-and-rating"
    - "extract-primary-color-product-images"
    - "deliver-results-to-mcp-connector"
  unsupported_tasks:
    - "purchase-or-add-to-cart"
    - "check-stock-or-inventory-levels"
    - "extract-size-or-color-variant-matrix"
    - "extract-full-review-history (only the 5 most recent)"
    - "paginate-beyond-the-first-category-listing-page"
    - "scrape-non-quince-retailers"
    - "multi-category-or-multi-query-in-one-run"
    - "scrape-non-us-storefronts (US storefront only)"
  search_keywords:
    - "quince scraper"
    - "quince.com product data"
    - "quince price tracker"
    - "dtc apparel pricing data"
    - "cashmere price monitoring"
    - "ecommerce product scraper"
    - "competitor price intelligence"
    - "product review scraper"
    - "affiliate product feed"
    - "mcp ecommerce tool"
  synonyms:
    - "quince crawler"
    - "quince product extractor"
    - "quince catalog feed"
    - "quince price monitor"
  related_concepts:
    ["products", "prices", "discounts", "reviews", "ratings", "apparel", "home goods", "DTC retail"]
  input_entities:
    - "input mode (fuzzy_search | category | product_urls)"
    - "search query (free text)"
    - "category slug (1 of 323 enum values)"
    - "product URL list (quince.com only)"
  output_entities: ["product", "price", "discount", "review", "image"]
  input_rules:
    mode_dependency:
      description: "Each mode reads exactly one companion field; the others are ignored."
      mapping:
        fuzzy_search: "searchQuery (+ searchLimit)"
        category: "category (+ categoryMaxProducts)"
        product_urls: "productUrls"
    product_url_format:
      regex: "^https?://(www\\.)?quince\\.com/.+"
      description: "Host must be exactly quince.com or www.quince.com. Must be a product detail page, not a category or landing page."
      examples: ["https://www.quince.com/women/lightweight-cotton-cashmere-dolman-sleeve-sweater"]
    category_format:
      type: "enum"
      description: "Path slug from Quince's mega-menu, leading slash included."
      examples: ["/women/sweaters", "/home/bedding", "/men/linen", "/jewelry/new-arrivals"]
  default_off_fields: []
  limits:
    search_max_products: 500
    category_max_products_setting: 5000
    category_actual_ceiling: "first listing page only, typically ~30 products"
    reviews_per_product: 5
    free_plan_result_cap: 5
    modes_per_run: 1
  pricing:
    model: "pay-per-result"
    unit_cost_usd: 0.015
    rate_per_1000: 15.00
    note: "'from' price — lower rates apply on higher Apify subscription tiers"
  when_to_use: >
    You need structured Quince.com product data — pricing, discount depth,
    hero imagery, ratings and recent reviews — for competitive price
    intelligence, deal monitoring, affiliate/comparison feeds, or assortment
    research.
  when_not_to_use: >
    You need stock levels, size/colour variant matrices, complete review
    history, deep category pagination, a non-US storefront, any retailer
    other than Quince, or to actually buy anything.
  alternatives:
    - "Use a general-purpose web scraper if the target is not quince.com"
    - "Use product_urls mode with a URL list when you need specific SKUs rather than a category sweep"
```

***

```json
{
    "@context": "https://schema.org/",
    "@type": "SoftwareApplication",
    "name": "Quince.com Product Scraper",
    "alternateName": "Quince.com Product Scraper — Prices, Discounts, Reviews & Images",
    "applicationCategory": "DeveloperApplication",
    "applicationSubCategory": "Web Scraping / E-commerce Product & Price Data",
    "operatingSystem": "Cloud (Apify platform)",
    "description": "Extracts structured Quince.com product data — selling price, retail price, computed discount, hero images, latest reviews and ratings — by keyword search, category slug, or product URL list, with optional delivery to Notion, Slack, Google Sheets, Airtable, or any authorized MCP connector.",
    "url": "https://apify.com/techforce.global/quince-scraper",
    "offers": {
        "@type": "Offer",
        "price": "15.00",
        "priceCurrency": "USD",
        "description": "From $15.00 per 1,000 products on the entry tier, less on higher Apify subscription tiers. Apify platform usage is billed separately. Current rates are shown on the Actor's Apify Store page.",
        "url": "https://apify.com/techforce.global/quince-scraper"
    }
}
```

***

### What this Actor does

- Discovers products **three ways**: free-text **keyword search** (served by Quince's Algolia index, not the client-rendered HTML page), a **323-entry category dropdown** built from Quince's live mega-menu, or a **list of product URLs** you paste.
- Returns one record per product: title, plain-text description, **selling price**, **strike-through retail price**, **pre-computed discount percentage**, primary-colour **hero images**, the **5 most recent reviews**, **average rating**, and **total review count**.
- **Masks email-shaped reviewer handles** (`k***@***`) so a public dataset never leaks reviewer addresses.
- **Pushes every record to the dataset the moment it is extracted**, so a proxy hiccup or a parser-drift failure mid-run never wipes earlier progress.
- **Never aborts on one bad product.** A failed PDP is logged and skipped; a URL that isn't a product page is saved with an explanatory `note` field instead of being silently dropped.
- Detects **proxy-shaped failures** specifically and prints actionable guidance once per run instead of repeating raw curl errors.
- Routes traffic through **Apify Proxy** with Chrome TLS impersonation (`curl_cffi`), retrying transient network failures up to 5 times with exponential backoff.
- Optionally **pushes results to an authorized MCP connector** (Notion, Slack, Google Sheets, Airtable, Linear, or any MCP-compatible connector) in four delivery modes. The dataset is always saved regardless of delivery settings.

### When to use it — and when not to

| Scenario | Fit |
| --- | --- |
| Competitive price & discount intelligence on Quince SKUs | ✅ Strong |
| Deal / markdown monitoring for a newsletter or Slack alert | ✅ Strong (native MCP delivery) |
| Affiliate or comparison-site product feed (title, price, image, rating) | ✅ Strong |
| Assortment & trend research on a category | ✅ Strong |
| Pull specific SKUs you already have URLs for | ✅ Strong — `product_urls` mode |
| Review-sentiment sampling | ⚠️ Only the **5 most recent** reviews per product |
| Sweeping a whole large category (hundreds of SKUs) | ⚠️ First listing page only, typically ~30 products — see Execution Rules |
| Several categories or queries at once | ⚠️ One mode, one query/category per run |
| Non-US storefront pricing | ❌ US storefront (`quince.com`) only — all prices are USD |
| Stock levels, size/colour variant matrices | ❌ Not extracted |
| Buying, carting, or checkout | ❌ Not supported — read-only Actor |
| Any retailer other than quince.com | ❌ Not supported |

***

### ⚡ Execution Rules (Avoid Common Agent Failures)

1. **`mode` decides which other fields matter.** `fuzzy_search` reads `searchQuery` + `searchLimit`; `category` reads `category` + `categoryMaxProducts`; `product_urls` reads `productUrls`. Fields belonging to the other modes are ignored entirely — setting `searchQuery` in `category` mode does nothing.
2. **`mode` is the only required field, and it defaults to `fuzzy_search`.** Since `searchQuery` defaults to `""`, an input of `{}` produces a **successful run with zero items** and the terminal status message `Skipped: Please enter a search query before running.`
3. **Invalid input does not fail the run.** Empty query, unpicked category, empty URL list, unknown mode, or an Algolia credential failure all end as `SUCCEEDED` with `itemCount: 0` and a `Skipped: …` status message. **Agents must read `itemCount` and the status message, not just run status.**
4. **`categoryMaxProducts` is a ceiling, not a target.** Category mode fetches **one listing page** and extracts the products embedded in its SSR payload — typically ~30. Setting `5000` does not paginate; you will still get roughly one page. For larger sweeps, use several narrower category slugs, or `product_urls` mode with a URL list.
5. **`category` values are exact path slugs from a fixed list of 323**, leading slash included: `/women/sweaters`, `/home/bedding`, `/men/linen`. Not display names — `"Sweaters"` is invalid.
6. **`productUrls` must be product detail pages on `quince.com` or `www.quince.com`.** A category, search, or marketing URL is reachable but is **not** a PDP: the Actor saves a record carrying `note` and no product fields. Lookalike hosts (`evil-quince.com`) are rejected outright.
7. **US storefront only.** `region` accepts a single value, `US`; every request goes to `www.quince.com` and all prices are USD. Do not present output as pricing for any other market. (Proxy *country* is a separate setting — see `proxy` — and does not change the storefront.)
8. **Missing values are the string `"N/A"`, never `null`.** This applies to `sellingPrice`, `retailPrice`, `discount`, `averageRating`, `reviewCount`, and even `images`/`reviews` — which are the **string** `"N/A"` rather than an empty array when absent. Type-check before iterating.
9. **Free Apify plans are capped at 5 products per run**, applied by clamping `searchLimit` / `categoryMaxProducts` / the `productUrls` list. This is a successful run, not a failure.
10. **`deliveryMode` defaults to `summary`, not `none`.** For dataset-only runs, either leave `mcpConnector` empty or set `deliveryMode: "none"` explicitly.
11. **Only successfully-extracted products are delivered.** Records that are placeholder/skip rows (title `"N/A"`) stay in the dataset but are excluded from connector payloads.

```yaml
dependencies:
  - rule: "mode selects its companion field; other modes' fields are ignored"
    on_violation: "run succeeds with 0 items and a 'Skipped: ...' status message"
  - rule: "delivery requires mcpConnector AND mcpTool"
    on_violation: "delivery step is skipped with a warning; the dataset is still written in full"
  - rule: "mcpArguments must reference {message} for the rendered template to appear anywhere"
    on_violation: "message body is empty; the tool is still called"
  - rule: "mcpConnector only resolves when the Actor runs on the Apify platform"
    on_violation: "local runs log 'APIFY_MCP_PROXY_URL is not set' and skip delivery; the dataset is unaffected"
  - rule: "perProduct mode issues one connector call per product"
    note: "a 200-product category run is 200 calls — prefer 'chunked' or 'summary'"
authentication:
  actor_input: none
  platform: "Apify API token required for API / SDK / MCP invocation; paid plan required for residential proxy groups"
  target_site: "no Quince account or credentials required (public product pages only)"
```

***

### 📥 Input Contract

`.actor/input_schema.json` is authoritative — if any table on this page disagrees with the schema files, **the schema files win**. API and MCP clients should always pass `mode` plus that mode's companion field explicitly.

#### Scraping Parameters

| Field | Type | Required | Default | Allowed Values / Format | Example |
| :--- | :--- | :--- | :--- | :--- | :--- |
| `mode` | string (enum) | ✅ Yes | `fuzzy_search` | `fuzzy_search` · `category` · `product_urls` | `category` |
| `searchQuery` | string | ⚠️ If `mode = fuzzy_search` | `""` | Free text | `mongolian cashmere crewneck` |
| `searchLimit` | integer | ⬜ No | `50` | `1` to `500` | `100` |
| `category` | string (enum) | ⚠️ If `mode = category` | `/women/sweaters` | 323 exact path slugs | `/home/bedding` |
| `categoryMaxProducts` | integer | ⬜ No | `200` | `1` to `5000` (see Rule 4) | `100` |
| `productUrls` | array of string | ⚠️ If `mode = product_urls` | `[]` | `^https?://(www\.)?quince\.com/.+` | `["https://www.quince.com/women/..."]` |
| `region` | string (enum) | ⬜ No | `US` | `US` only — US storefront, USD prices | `US` |
| `proxy` | object | ⬜ No | Apify Proxy, `RESIDENTIAL`, country `US` (prefill) | Apify proxy editor object | see below |
| `maxConcurrency` | integer | ⬜ No (hidden) | `10` | `1` to `100` — **not yet wired**; PDPs are fetched sequentially | — |
| `maxRequestRetries` | integer | ⬜ No (hidden) | `3` | `0` to `10` — **not yet wired**; retries are fixed at 5 attempts | — |

#### Mode → required field map

| `mode` | You must set | Volume knob | Produces |
| :--- | :--- | :--- | :--- |
| `fuzzy_search` | `searchQuery` | `searchLimit` (max 500) | One record per matching product from Quince's Algolia index |
| `category` | `category` | `categoryMaxProducts` (first page only, ~30) | One record per product on the category's first listing page |
| `product_urls` | `productUrls` | length of the list | One record per URL — including `note` rows for non-product URLs |

#### Category reference

323 slugs, taken from Quince's live mega-menu and refreshed via `scripts/fetch_categories.py`. Representative values:

| Area | Example slugs |
| --- | --- |
| Women | `/women`, `/women/sweaters`, `/women/dresses`, `/women/cashmere`, `/women/silk`, `/women/jeans`, `/women/shoes/sandals` |
| Men | `/men`, `/men/linen`, `/men/best-sellers` |
| Home | `/home/bedding`, `/home/candles`, `/home/travel` |
| Jewelry & accessories | `/jewelry/new-arrivals`, `/women/jewelry/earrings-all`, `/women/bags-&-leather-goods` |
| Beauty & wellness | `/beauty-&-wellness/skincare`, `/beauty-&-wellness/fragrance` |
| Edits & seasonal | `/all/new-arrivals`, `/all/best-sellers`, `/the-spring-edit`, `/style-gone-viral`, `/linen` |

The Console dropdown carries the full list — pick from it rather than hand-writing slugs.

#### Examples

Keyword search:

```json
{
  "mode": "fuzzy_search",
  "searchQuery": "mongolian cashmere crewneck",
  "searchLimit": 50,
  "deliveryMode": "none"
}
```

Category browse:

```json
{
  "mode": "category",
  "category": "/women/sweaters",
  "categoryMaxProducts": 100,
  "deliveryMode": "none"
}
```

Specific products:

```json
{
  "mode": "product_urls",
  "productUrls": [
    "https://www.quince.com/women/lightweight-cotton-cashmere-dolman-sleeve-sweater",
    "https://www.quince.com/women/100-organic-cotton-button-front-cardigan"
  ],
  "deliveryMode": "none"
}
```

Recommended proxy block:

```json
{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

#### MCP Delivery Configuration (Optional)

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `mcpConnector` | string | `""` | Authorized MCP connector on your Apify account (Notion, Slack, Airtable, Google Sheets, Linear, …). Leave empty for dataset-only runs. |
| `deliveryMode` | enum | `summary` | `summary` (single digest) · `chunked` (split large lists) · `perProduct` (one call per item) · `none`. |
| `mcpTool` | string | `""` | Tool name on the connector: `send_message`, `create_page`, `append_row`. Run once with a connector selected — the log lists the connector's available tools. |
| `mcpArguments` | object | `{}` | Arguments passed to the tool. String leaves support `{placeholders}`. |
| `mcpMessageTemplate` | string | `""` | Template rendered and exposed to `mcpArguments` as `{message}`. |

**Placeholders by mode:**

| Mode | Placeholders |
| :--- | :--- |
| `summary` | `{mode}` (the raw input mode — `fuzzy_search` / `category` / `product_urls`), `{sourceInput}` (your query, slug, or first URL), `{productCount}`, `{productsText}`, `{message}` |
| `chunked` | the above, plus `{part}` and `{partCount}` — and `{productsText}` holds one part |
| `perProduct` | `{title}`, `{url}`, `{description}`, `{sellingPrice}`, `{retailPrice}`, `{discount}`, `{averageRating}`, `{reviewCount}`, `{imageUrl}` (first hero image), `{productText}`, plus `{mode}`, `{sourceInput}`, `{productCount}`, `{message}` |

Placeholders render `"N/A"` sentinels as empty strings, so a template never posts a literal `N/A`.

Slack deal alert:

```json
{
  "mode": "category",
  "category": "/women/cashmere",
  "mcpConnector": "<your-authorized-slack-connector>",
  "deliveryMode": "summary",
  "mcpTool": "send_message",
  "mcpMessageTemplate": "Quince {sourceInput} — {productCount} products:\n\n{productsText}",
  "mcpArguments": { "channel": "#deals", "text": "{message}" }
}
```

Google Sheets, one row per product:

```json
{
  "mode": "category",
  "category": "/women/sweaters",
  "mcpConnector": "<your-authorized-sheets-connector>",
  "deliveryMode": "perProduct",
  "mcpTool": "append_row",
  "mcpArguments": {
    "values": ["{title}", "{sellingPrice}", "{retailPrice}", "{discount}", "{averageRating}", "{url}"]
  }
}
```

Chunked delivery groups products into parts under ~72,000 characters and truncates any single product block at ~1,800 characters, so services with per-request block or timeout caps (Notion in particular) never reject the call.

***

### 📤 Output Contract & Data Structure

**Storage:** Apify Dataset (one JSON object per product).
**Pagination:** `limit` & `offset` on the dataset items endpoint.
**Duplicates:** `product_urls` mode dedupes the input list; within a run each product appears once. Cross-run deduplication is the consumer's responsibility — use `url` as the key.

| Field | Type | `"N/A"` possible | Meaning |
| --- | --- | --- | --- |
| `url` | string | No | Canonical product page URL — use as the dedupe key |
| `title` | string | Yes | Product display name. `"N/A"` marks a placeholder/skip row |
| `description` | string | Yes | Product description, HTML stripped to plain text |
| `sellingPrice` | string | Yes | Current price, `$`-prefixed — e.g. `"$39.90"` |
| `retailPrice` | string | Yes | Strike-through "was" price — e.g. `"$79"` |
| `discount` | string | Yes | Computed savings — e.g. `"49.5%"`. `"N/A"` for full-price items |
| `images` | array of string **or** `"N/A"` | Yes | Hero images for the primary colour only |
| `reviews` | array of object **or** `"N/A"` | Yes | The **5 most recent** reviews, newest first |
| `reviews[].rating` | number | — | 1–5 star rating |
| `reviews[].title` | string | Yes | Review headline |
| `reviews[].body` | string | Yes | Review text |
| `reviews[].author` | string | Yes | Display name, or a masked handle (`k***@***`) if it looked like an email |
| `reviews[].createdAt` | string | Yes | Review timestamp as published, `YYYY-MM-DD HH:MM:SS` |
| `averageRating` | number/string | Yes | Overall average rating, 1–5 |
| `reviewCount` | number/string | Yes | Total reviews on the product |
| `sourceKind` | string | No | Which mode produced the record: `fuzzy_search`, `category`, or `product_urls` |
| `sourceInput` | string | No | The query, slug, or URL you supplied |
| `note` | string | absent | **Only present on skip rows** — explains why no product data was extracted (non-PDP URL, or an HTTP error status) |

**Two shapes to expect:** a normal product record, and a *skip row* (`title: "N/A"` plus `note`). Branch on `note` presence — or on `title != "N/A"` — before treating an item as a product.

**`images` and `reviews` are not always arrays.** When absent they are the string `"N/A"`. Guard with a type check (`isinstance(x, list)`) rather than iterating blindly.

#### Example output item

```json
{
  "url": "https://www.quince.com/women/lightweight-cotton-cashmere-dolman-sleeve-sweater",
  "title": "Lightweight Cotton Cashmere Link-Stitch Dolman Sweater",
  "description": "Experience the perfect blend of luxury and comfort with our Lightweight Cotton Cashmere Link-Stitch Dolman Sweater.",
  "sellingPrice": "$39.90",
  "retailPrice": "$79",
  "discount": "49.5%",
  "images": [
    "https://images.ctfassets.net/.../W-SWT-40-SGSTNE_1063_EDITED.jpg",
    "https://images.ctfassets.net/.../W-SWT-40-SGSTNE_1120_EDITED.jpg"
  ],
  "reviews": [
    {
      "rating": 5,
      "title": "Flattering",
      "body": "This sweater is so flattering that I have it in two colors and will probably buy more.",
      "author": "k***@***",
      "createdAt": "2026-05-22 04:52:07"
    }
  ],
  "averageRating": 4.88,
  "reviewCount": 15697,
  "sourceKind": "category",
  "sourceInput": "/women/sweaters"
}
```

#### Example skip row

```json
{
  "url": "https://www.quince.com/women/sweaters",
  "sourceKind": "product_urls",
  "sourceInput": "https://www.quince.com/women/sweaters",
  "note": "URL is on quince.com but does not look like a product page. It may be a category, search, or marketing page. Try using 'Category browse' or 'Fuzzy search' mode for those."
}
```

#### What a successful run looks like

```json
{
  "status": "SUCCEEDED",
  "defaultDatasetId": "<datasetId>",
  "stats": { "itemCount": 30 }
}
```

The terminal status message carries the real summary — `Extracted 30 product(s).`, plus counts of skipped URLs, proxy failures, and connector messages when relevant. A `SUCCEEDED` run with `itemCount: 0` and a `Skipped: …` status message means **the input was unusable**, not that Quince had no matches.

***

### ▶️ Invocation & Integration

**Lifecycle:** Discover → Understand → Configure → Execute → Retrieve → Validate. Authenticate every call with `Authorization: Bearer <APIFY_TOKEN>`.

#### Apify Console

Open the Actor → **Input** tab → pick a **mode** → fill that mode's field (query, category dropdown, or URL list) → set the volume cap → confirm the proxy block → **Start** → export from the **Dataset** tab (JSON, CSV, Excel, XML, RSS).

#### Model Context Protocol (MCP)

Add this Actor directly as an AI tool in Claude Desktop, Cursor, VS Code, or LangChain agents:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=techforce.global/quince-scraper"
```

#### Python (apify-client)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run = client.actor("techforce.global/quince-scraper").call(run_input={
    "mode": "category",
    "category": "/women/cashmere",
    "categoryMaxProducts": 100,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
    "deliveryMode": "none",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
products = [i for i in items if i.get("title") not in (None, "N/A")]
print(f"{len(products)} products, {len(items) - len(products)} skipped rows")

for p in products[:5]:
    print(f'{p["title"]}: {p["sellingPrice"]} (was {p["retailPrice"]}, {p["discount"]} off)')
```

#### JavaScript / TypeScript (apify-client)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('techforce.global/quince-scraper').call({
  mode: 'fuzzy_search',
  searchQuery: 'linen shirt',
  searchLimit: 50,
  deliveryMode: 'none',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const discounted = items.filter((i) => i.discount && i.discount !== 'N/A');
console.log(`${discounted.length} of ${items.length} items are on markdown`);
```

#### cURL — synchronous (returns items directly; 300s limit)

```bash
curl -X POST \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"mode":"category","category":"/women/sweaters","categoryMaxProducts":50,"deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~quince-scraper/run-sync-get-dataset-items'
```

#### cURL — asynchronous with a spend cap (recommended for production)

```bash
## 1. Start execution with a hard spend limit
curl -X POST -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"mode":"fuzzy_search","searchQuery":"cashmere sweater","searchLimit":200,"deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~quince-scraper/runs?maxTotalChargeUsd=3.00'

## 2. Poll
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/actor-runs/%3CrunId%3E'

## 3. Retrieve when SUCCEEDED
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/datasets/%3CDATASET_ID%3E/items?clean=true&format=json&limit=1000&offset=0'
```

***

### ⚠️ Autonomous Agent Error Handling & Resolution Matrix

| Error Code | Detection Condition | Underlying Cause | Deterministic Agent Action |
| :--- | :--- | :--- | :--- |
| `AUTH_INVALID` | HTTP `401` | Missing or malformed `APIFY_TOKEN` | **Abort & Prompt User:** request a valid API token. |
| `RATE_LIMITED` | HTTP `429` | Apify API rate / concurrency limits | **Retry:** exponential backoff (2s, 4s, 8s). |
| `SYNC_TIMEOUT` | HTTP `408` on the sync endpoint | Run exceeded the 300s synchronous ceiling | **Reconfigure:** switch to async `POST /runs` + polling. |
| `INPUT_SKIPPED` | `SUCCEEDED`, `itemCount: 0`, status starts `Skipped:` | Empty query, unpicked category, empty/invalid URL list, or unknown mode | **Modify Input:** read the status message — it names the exact missing field. |
| `SEARCH_UNAVAILABLE` | `SUCCEEDED`, 0 items, status mentions `Could not run search` | Quince's Algolia credentials could not be resolved from the page | **Retry once**, then fall back to `category` or `product_urls` mode. |
| `NO_SEARCH_MATCH` | `SUCCEEDED`, 0 items, status mentions `No products matched` | Query too narrow or misspelled | **Modify Input:** broaden the keyword. |
| `BAD_HOST` | `SUCCEEDED`, 0 items, status mentions `must be on quince.com` | A URL pointed at another host | **Modify Input:** keep every URL on `quince.com`/`www.quince.com`. |
| `NOT_A_PDP` | Item carries `note` and `title: "N/A"` | A category/search/landing URL was passed in `product_urls` mode | **Modify Input:** switch to `category` mode, or supply real PDP URLs. |
| `SITE_UNREACHABLE` | `FAILED` — `Could not reach Quince.com (HTTP …)` | Homepage probe failed before any scraping | **Retry:** re-run; if persistent, change proxy country/group. |
| `CHALLENGED` | `FAILED` — `Quince.com is temporarily refusing the request` | Cloudflare challenge detected on the homepage probe | **Reconfigure:** enable `RESIDENTIAL` proxy, then retry. |
| `PROXY_FAILURE` | Status message mentions `request(s) failed due to a proxy issue` | Residential tunnel failures mid-run (partial results saved) | **Consume partial data**, then re-run; switch country (US → CA) or group. |
| `CATEGORY_UNDERFILL` | `itemCount` ≈ 30 despite a much larger `categoryMaxProducts` | No pagination — one listing page per run | **Reconfigure:** use several narrower category slugs, or `product_urls` mode. |
| `FREE_PLAN_CAP` | `itemCount` ≤ 5 with the upgrade banner in the log | Free Apify plan caps results at 5 per run | **Prompt User:** upgrade for full-volume runs. |
| `DELIVERY_SKIPPED` | Log `no tool name was provided` | `mcpConnector` set but `mcpTool` empty | **Modify Input:** set `mcpTool`; the dataset is already saved. |
| `DELIVERY_TOOL_UNKNOWN` | Log `Tool 'x' is not available on this connector` | Wrong tool name for that connector | **Modify Input:** pick a name from the `Available tools:` list in the same log line. |
| `DELIVERY_EMPTY` | Connector called, body empty | `mcpArguments` omitted the `{message}` placeholder | **Modify Input:** map `{message}` inside `mcpArguments`. |
| `MCP_PROXY_MISSING` | Log `APIFY_MCP_PROXY_URL is not set` | Running locally instead of on the platform | **Reconfigure:** `apify push` and run on the platform. |
| `CHARGE_LIMIT` | Run aborted before the volume cap was reached | `maxTotalChargeUsd` spend threshold reached | **Prompt User:** confirm a higher spend cap. |

> **Reading run status:** a run that extracts nothing still finishes `SUCCEEDED` — the terminal status message says which input was unusable, and skip rows in the dataset carry a `note` explaining each rejected URL. Only a `FAILED` status is a platform-level failure. Every status-message and log-line condition in the table above comes from this Actor’s own behavior; the `401`/`408`/`429` rows are standard Apify API responses.

***

### 🗣️ Natural Language → Actor Mapping

| User says | Intent | Constructed Actor input |
| --- | --- | --- |
| "Find Quince cashmere crewnecks" | Keyword search | `{"mode":"fuzzy_search","searchQuery":"cashmere crewneck","searchLimit":50}` |
| "What's in Quince's women's sweaters category?" | Category browse | `{"mode":"category","category":"/women/sweaters"}` |
| "Scrape these 3 Quince product pages" | Direct extraction | `{"mode":"product_urls","productUrls":["…","…","…"]}` |
| "How much is Quince discounting right now?" | Discount monitoring | `{"mode":"category","category":"/all/best-sellers"}` then read `discount` |
| "Show me Quince's newest arrivals" | Assortment research | `{"mode":"category","category":"/all/new-arrivals"}` |
| "Compare Quince linen prices to ours" | Price intelligence | `{"mode":"category","category":"/linen"}` then read `sellingPrice` / `retailPrice` |
| "What are people saying about this Quince sweater?" | Review sampling | `{"mode":"product_urls","productUrls":["<pdp>"]}` then read `reviews` (5 most recent) |
| "Build a product feed for my affiliate site" | Feed generation | `{"mode":"category","category":"<slug>"}` then use `title`, `sellingPrice`, `images`, `averageRating` |
| "Post today's Quince markdowns to Slack" | Pipeline/delivery | `{"mode":"category","category":"/all/best-sellers","mcpConnector":"slack","deliveryMode":"summary","mcpTool":"send_message","mcpArguments":{"channel":"#deals","text":"{message}"}}` |
| "Track Quince bedding prices in a Google Sheet" | Export/delivery | `{"mode":"category","category":"/home/bedding","deliveryMode":"perProduct","mcpTool":"append_row"}` |
| "Save Quince jewelry research to Notion" | Pipeline/delivery | `{"mode":"category","category":"/jewelry/new-arrivals","deliveryMode":"chunked","mcpTool":"create_page"}` |
| "Is this Quince sweater in stock in size M?" | Inventory check | ❌ Out of scope — stock and variants are not extracted |

**Should NOT route here:** any retailer other than quince.com · stock/inventory checks · size or colour variant matrices · complete review history (only the 5 newest) · non-US storefront pricing · buying, carting, or checkout · generic "scrape any website" requests.

***

### 🧭 Agent Execution & Routing Logic

```text
[Input User Query]
       │
       ▼
1. Target is quince.com?                          NO  → Route to a general or retailer-specific Actor
       │ YES
       ▼
2. Read-only product data (not carting/checkout)? NO  → Abort (transactional ops unsupported)
       │ YES
       ▼
3. Needs stock, variants, or full review history? YES → Abort (not extracted)
       │ NO
       ▼
4. Pick the mode:
       ├── specific SKUs / URLs in hand → mode "product_urls"  (verify each is a PDP)
       ├── a browsable section          → mode "category"      (pick from the 323 slugs)
       └── free-text intent             → mode "fuzzy_search"  (searchQuery required)
       │
       ▼
5. Set that mode's volume knob only               → search: searchLimit ≤ 500
       │                                            category: ~1 page regardless of the cap
       ▼
6. Non-US market pricing required?                YES → Abort/flag: US storefront (USD) only
       │ NO
       ▼
7. Residential proxy available on this plan?      NO  → Warn: Cloudflare-challenge risk
       │ YES
       ▼
8. Deliver to a connector?                        YES → set mcpConnector + mcpTool + {message} in mcpArguments
       │ NO  → set deliveryMode "none"
       ▼
9. Estimated cost within budget?                  NO  → Reduce the cap / set maxTotalChargeUsd / prompt user
       │
       ▼
[Execute Apify Actor]
       │
       ├──► status == "SUCCEEDED" ──► itemCount == 0?  YES → read status message ("Skipped: ...") → fix input
       │                              │ NO
       │                              └──► drop skip rows (title == "N/A" / note present) → consume products (dedupe via 'url')
       └──► status == "FAILED"    ──► route to Error Handling Matrix above
```

***

### 💰 Cost Control & Pricing Transparency

- **Pay-per-result pricing:** **from $15.00 per 1,000 products** ($0.015 per product) — the "from" rate applies on the entry tier and drops on higher Apify subscription tiers. No monthly subscription.
- **Free Apify plans** receive up to 5 products per run as a preview, with an upgrade notice in the log.
- **Autonomous spend caps:** pass `maxTotalChargeUsd` as a query parameter on the run endpoint for a hard per-execution ceiling — important for any agent spending on your behalf.
- **Skip rows count as dataset items.** A `product_urls` run full of category URLs still writes records; keep the URL list clean so you pay for products, not notes.

| Products extracted | Total Cost (USD, entry tier) |
| :--- | :--- |
| 5 products (free-plan preview) | $0.00 |
| 30 products (typical single category page) | $0.45 |
| 50 products (default search run) | $0.75 |
| 200 products | $3.00 |
| 500 products (search ceiling) | $7.50 |
| 1,000 products (batched across runs) | $15.00 |

> ℹ️ **Always confirm the live rate on the Actor’s [Apify Store page](https://apify.com/techforce.global/quince-scraper) before committing to a large run.** The Store listing is what bills you, Apify platform usage is charged in addition to the per-product rate, and the table above is a worked example at the entry-tier rate.

***

### 🔍 Companion machine-readable files

| File | Purpose |
| --- | --- |
| `.actor/actor.json` | Identity, version, default run options (3600s timeout, 4096 MB), and the inline dataset view definition |
| `.actor/input_schema.json` | Authoritative typed input contract — `mode` enum, 323-value `category` enum, URL pattern for `productUrls`, `deliveryMode` enum |
| `.actor/output_schema.json` | Declares where results are stored |
| `data/categories.json` | The category slug catalogue behind the dropdown |
| `scripts/fetch_categories.py` | Regenerates the category list from Quince's live mega-menu |
| `src/modes.py` | Mode router — turns input into seed URLs and raises the "Skipped:" validation messages |
| `src/algolia.py` | Direct Algolia search client used by `fuzzy_search` mode |
| `src/pdp.py` | Product-page parsing, price/discount maths, image filtering, review masking |
| `src/http_client.py` | `curl_cffi` fetch with Chrome TLS impersonation, proxy routing, and 5-attempt backoff |
| `src/delivery.py` | MCP connector delivery modes and `{placeholder}` rendering |
| `src/connector.py` | MCP session handling through the Apify MCP Proxy |

Note: this Actor has **no separate `dataset_schema.json`** — the dataset view lives inline in `.actor/actor.json`.

If any table on this page disagrees with the schema files, **the schema files win**.

***

### 🛠️ Troubleshooting

Most zero-result runs are **input problems that end as `SUCCEEDED`**, not crashes. Read the terminal status message first — it usually names the exact fix.

| # | Symptom you see | Most likely cause | Fix |
| :-- | :--- | :--- | :--- |
| 1 | `SUCCEEDED`, 0 items, status `Skipped: Please enter a search query before running.` | `mode` is `fuzzy_search` (the default) with an empty `searchQuery` | Set `searchQuery`, or switch mode. |
| 2 | `SUCCEEDED`, 0 items, status `Skipped: Please pick a category…` | `mode: category` with no `category` | Pick a slug from the dropdown. |
| 3 | `SUCCEEDED`, 0 items, status `Skipped: Please paste at least one product URL…` | `mode: product_urls` with an empty list | Add PDP URLs. |
| 4 | ~30 products when you asked for hundreds | Category mode reads **one listing page**; no pagination | Use several narrower slugs, or `product_urls` mode with a URL list. |
| 5 | Exactly 5 products every run | Free Apify plan cap | Upgrade the plan; the log prints the upgrade banner. |
| 6 | Items with `title: "N/A"` and a `note` | Non-PDP URL, or the page returned an HTTP error | Expected. Filter them out, or fix the URL list. |
| 7 | `FAILED` — *Quince.com is temporarily refusing the request* | Cloudflare challenge on the homepage probe | Enable `RESIDENTIAL` proxy and retry. |
| 8 | `FAILED` — *Could not reach Quince.com (HTTP …)* | Network/proxy failure on the homepage probe | Retry; change proxy country or group. |
| 9 | Status mentions *request(s) failed due to a proxy issue* | Residential tunnel hiccups mid-run | Partial results were saved. Re-run, or switch country (US → CA) / group. |
| 10 | Status mentions *Could not run search* | Algolia credentials could not be resolved from the page | Retry once, then use `category` or `product_urls` mode. |
| 11 | Input rejected for `"region": "CA"` | Only `US` is a valid value — the Actor serves the US storefront | Pass `"US"` or omit the field. Proxy *country* is configured separately under `proxy`. |
| 12 | `maxConcurrency` / `maxRequestRetries` appear to do nothing | Both are hidden inputs and **not wired**; fetches are sequential with 5 fixed retry attempts | Expected. Adjust the volume cap instead. |
| 13 | Consumer code crashes iterating `images` or `reviews` | They are the **string** `"N/A"` when absent, not `[]` | Type-check (`isinstance(x, list)`) before iterating. |
| 14 | `discount` is `"N/A"` on a real product | The product has no strike-through retail price — it is full price | Read `retailPrice` first; `"N/A"` there means no markdown. |
| 15 | Only 5 reviews per product | By design — the 5 most recent only | For full review history, a custom pipeline is required. |
| 16 | Reviewer names look like `k***@***` | Email-shaped handles are masked for privacy | Expected and intentional. |
| 17 | Prices have no currency code | Prices are `$`-prefixed strings from the US storefront | Strip `$` and treat as USD. |
| 18 | Slack / Notion / Sheets received nothing | Delivery needs **both** `mcpConnector` and `mcpTool`; otherwise it is skipped with a warning | Set both. The dataset is still written in full. |
| 19 | Log: *APIFY\_MCP\_PROXY\_URL is not set* | You ran locally with `apify run`; connectors only resolve on the platform | Deploy with `apify push` and run on the platform. |
| 20 | Connector fired, but the message body is empty | `mcpArguments` did not reference `{message}` | Map `{message}` in `mcpArguments` and populate `mcpMessageTemplate`. |
| 21 | Skip rows missing from the connector payload | Only successfully-extracted products are delivered | Expected. Read the dataset for the full picture. |
| 22 | Hundreds of connector calls fired | `deliveryMode: "perProduct"` sends one call per product | Switch to `chunked` or `summary`. |
| 23 | Delivery fired when you only wanted a dataset | `deliveryMode` defaults to `summary`, **not** `none` | Set `deliveryMode: "none"` or leave `mcpConnector` empty. |
| 24 | `HTTP 401` / `403` | Missing, expired, or malformed `APIFY_TOKEN` | Regenerate in **Apify Console → Settings → API & Integrations**, send as `Authorization: Bearer <token>`. |
| 25 | `HTTP 429` | Apify account concurrency / rate limits — not Quince blocking | Retry with exponential backoff (2s → 4s → 8s). |
| 26 | `HTTP 408` on `run-sync-get-dataset-items` | The synchronous endpoint has a hard **300-second** ceiling | Switch to async: `POST /runs` → poll `/actor-runs/<runId>` → fetch dataset. |

#### Diagnostic checklist before opening an issue

1. **Read the terminal status message**, not just the run status. `Skipped: …` means the input needs fixing; a `SUCCEEDED` run can still be a no-op.
2. **Baseline run.** `{"mode":"category","category":"/women/sweaters","categoryMaxProducts":10,"deliveryMode":"none"}` with residential proxy on.
3. **Products returned?** If yes, the site and proxy are fine — the problem is your mode or volume expectation (see Rule 4).
4. **Still zero?** Switch proxy country/group and re-run. Cloudflare challenges are the most common hard failure.
5. **Open the same page in a browser.** If Quince itself shows nothing, the slug or URL is stale.
6. **Check the run log** for the resolved seed URLs and per-product lines (`-> Title ($price)`), which show exactly where extraction stopped.

If the issue survives all six steps, open an **Issues** ticket on the Actor page (or email support) with the **run ID**, the **exact input JSON**, and what you expected. Run IDs let us replay the exact execution.

### ❓ FAQ

#### Setup & access

**Do I need a Quince account or API key?**

No. The Actor reads publicly available product pages. You need an **Apify** account and API token; you need no Quince credentials whatsoever.

**Is this an official Quince API?**

No. Quince publishes no public product API. This is an independent Actor and is not affiliated with, endorsed by, or sponsored by Quince.

**Do I need to configure proxies?**

Yes — keep the residential proxy on. Quince sits behind Cloudflare, and the homepage probe fails fast with a clear message when a challenge is served. Residential groups require a paid Apify plan.

**Can I plug it into Claude, Cursor, or a LangChain agent?**

Yes — it is a native MCP tool:

`claude mcp add --transport http apify "https://mcp.apify.com/?tools=techforce.global/quince-scraper"`

#### Input & modes

**Which mode should I use?**

`product_urls` when you already know the SKUs, `category` to sweep a section, `fuzzy_search` for free-text intent. One mode per run.

**Why did I only get ~30 products from a category?**

Category mode reads a single listing page and takes the products embedded in its SSR payload — there is no pagination. `categoryMaxProducts` caps that number; it cannot raise it. Use several narrower slugs, or supply product URLs.

**Can I scrape several categories or queries in one run?**

No — one mode and one query/category per run. Loop the Actor in your orchestration layer.

**Can I get Canadian or other non-US pricing?**

No. `region` accepts `US` only — every request goes to the US storefront (`www.quince.com`) and all prices are USD. Setting the Apify proxy country to another country does not change the storefront.

#### Output & data

**Why is everything `"N/A"` instead of `null`?**

By design — the extractor emits the string `"N/A"` for any missing value so downstream code never has to guard against `null`. The trade-off: `images` and `reviews` are also `"N/A"` (a string) when absent, so type-check before iterating.

**Why only 5 reviews?**

The Actor returns the 5 most recent reviews per product, plus `averageRating` and total `reviewCount` for the full picture.

**Are reviewer emails included?**

No. Author handles that look like email addresses are masked to `x***@***` before being written.

**Do I get stock levels or size/colour variants?**

No. Only the fields listed in the Output Contract, and images for the primary colour only.

#### Delivery

**What is the MCP connector for?**

It pushes the scraped products straight into a tool you have already authorized on your Apify account — Notion, Slack, Google Sheets, Airtable, Linear, or any MCP-compatible connector — with no glue code. Credentials stay private: delivery runs through the **Apify MCP Proxy**, so the Actor never sees your connector tokens.

**Which delivery mode should I use?**

`summary` for a digest, `chunked` for long lists into services with request caps (Notion), `perProduct` for row-per-product targets (Sheets/Airtable), `none` for dataset-only runs.

**Does delivery work when running locally?**

No. Connectors resolve through the Apify MCP Proxy, which only exists on the platform. Locally you'll see `APIFY_MCP_PROXY_URL is not set` and the dataset is saved as normal.

#### Limits & pricing

**What does it cost?**

From $0.015 per product — $15.00 per 1,000 results on the entry tier, less on higher subscription tiers. No monthly subscription.

**How do I guarantee an agent never overspends?**

Pass `maxTotalChargeUsd` as a query parameter on the run endpoint. It is a hard per-execution ceiling — the run stops rather than exceeding it.

***

### 🔗 Related Actors & pipeline patterns

#### Same data family — other e-commerce product scrapers

| Actor | Use it for |
| :--- | :--- |
| [Amazon Products Scraper](https://apify.com/techforce.global/amazon-scraper) | The same price, rating and review fields across Amazon's catalogue — the widest assortment for benchmarking Quince against mass-market pricing |
| [Flipkart Search Scraper](https://apify.com/techforce.global/flipkart-scraper) | Indian-market product and price data, for comparing the same category across a different storefront and currency |
| [Etsy Product Scraper](https://apify.com/techforce.global/etsy-scraper) | Handmade and independent-seller listings — the closest comparison set for Quince's positioning on quality-per-price |

All three return a comparable product record, so one pipeline can pull Quince alongside them and compare price, discount depth and review sentiment for the same product type.

#### Enrichment & downstream

| Actor | Use it for |
| :--- | :--- |
| [Advanced Website Crawling Actor](https://apify.com/techforce.global/advanced-website-crawling-actor) | Crawl a competitor's own site for clean HTML/Markdown/text context alongside Quince pricing |
| [Google Maps Scraper – Business Data](https://apify.com/techforce.global/google-maps-scraper) | Enrich retail or brand entities into full business records |
| [GOV.UK Business Scraper](https://apify.com/techforce.global/gov-uk-business-scraper) | Match UK supplier or brand names against Companies House records |

#### Suggested pipeline patterns

**📉 Daily markdown monitor**
Scheduled `category` run on `/all/best-sellers` → `deliveryMode: "summary"`, `mcpConnector: "slack"`, `mcpTool: "send_message"` → your channel gets the day's discount depth with no glue code.

**🛒 Affiliate product feed**
`category` runs across your target slugs → filter out skip rows (`title != "N/A"`) → `title`, `sellingPrice`, `images[0]`, `averageRating` → render on your site; refresh weekly.

**📊 Price-history warehouse**
Same slugs on a schedule → `deliveryMode: "perProduct"` into Google Sheets/Airtable, or dataset → ETL → track `sellingPrice` and `discount` per `url` over time.

**🔎 Assortment research**
`/all/new-arrivals` weekly → diff on `url` against last week → surface genuinely new SKUs and their launch pricing.

> Browse all Actors by Techforce Global at **[scraper.techforce.global](https://scraper.techforce.global/)**.

***

### 🔐 Compliance & Data Privacy

This is an independent Actor. It is **not** affiliated with, endorsed by, or sponsored by Quince. "Quince" is a trademark of its respective owner.

This Actor collects **publicly available** product listing data only. It does not log into accounts, bypass authentication, or access order, customer, or payment data. Review author display names are public profile strings and email-shaped handles are masked automatically, but reviewer names may still constitute personal data in some jurisdictions. You are responsible for ensuring your use complies with Quince's Terms of Service, applicable data-protection law (including GDPR and CCPA), and any local regulations. Product images and descriptions remain the copyright of their owner — check your rights before republishing them.

***

### 🆘 Support & Custom Pipeline Engineering

Need deep category pagination, full review history, additional regional storefronts, scheduled multi-category monitoring, or a warehouse sync?

- **Email**: bhavin.shah@techforceglobal.com
- **Custom Enterprise Integrations**: [Book a 15-Minute Technical Consultation](https://calendly.com/techforce-global/intro-meeting)
- **Maintained by**: [Techforce Global](https://www.techforceglobal.com) — Specialists in High-Performance Web Scrapers and Agentic Workflows.

***

Made with ❤️ by **[Techforce Global](https://www.techforceglobal.com)**
Specialists in High-Performance E-commerce Data Extraction and AI Automation.

***

### 🏷️ Structured data for search & AI discovery

`SoftwareApplication` describes the Actor; `FAQPage` wraps the FAQ above so those answers are
eligible for rich results, matching it question-for-question.

```json
{
  "@context": "https://schema.org/",
  "@type": "SoftwareApplication",
  "name": "Quince.com Product Scraper",
  "alternateName": "Quince.com Product Scraper — Prices, Discounts, Reviews & Images",
  "applicationCategory": "DeveloperApplication",
  "applicationSubCategory": "Web Scraping / E-commerce Product & Price Data",
  "operatingSystem": "Cloud (Apify platform)",
  "description": "Extracts structured Quince.com product data — selling price, retail price, computed discount, hero images, latest reviews and ratings — by keyword search, category slug, or product URL list, with optional delivery to Notion, Slack, Google Sheets, Airtable, or any authorized MCP connector.",
  "url": "https://apify.com/techforce.global/quince-scraper",
  "author": {
    "@type": "Organization",
    "name": "Techforce Global",
    "url": "https://www.techforceglobal.com/"
  },
  "provider": {
    "@type": "Organization",
    "name": "Apify",
    "url": "https://apify.com/"
  },
  "offers": {
    "@type": "Offer",
    "price": "15.00",
    "priceCurrency": "USD",
    "description": "From $15.00 per 1,000 products on the entry tier, less on higher Apify subscription tiers. Apify platform usage is billed separately. Current rates are shown on the Actor's Apify Store page.",
    "url": "https://apify.com/techforce.global/quince-scraper"
  },
  "featureList": [
    "No Quince account, API key or credentials required",
    "Three input modes: free-text search, category dropdown, or a product URL list",
    "Free-text search resolved through Quince's own search index rather than HTML scraping",
    "323 preset category slugs selectable from a dropdown",
    "Selling price and strike-through retail price on every product",
    "Discount percentage computed from the two prices",
    "Hero images for the primary colourway, deduplicated and absolute",
    "The five most recent reviews per product, with email-shaped author handles masked",
    "Average rating and total review count for the full picture beyond the five reviews",
    "Every row stamped with the mode and the exact query, slug or URL that produced it",
    "Non-product URLs written as explicit skip rows with the reason, never silently dropped",
    "Records pushed as each product completes, so a mid-run failure keeps earlier progress",
    "Proxy failures detected and answered with specific remediation guidance in the log",
    "Missing values emitted as the string N/A so consumers never guard against null",
    "Optional MCP delivery to Notion, Slack, Google Sheets, Airtable, Linear and more",
    "Chunked delivery mode keeps long product lists under connector size and timeout caps"
  ],
  "isAccessibleForFree": false,
  "softwareRequirements": "Apify account and API token",
  "softwareHelp": {
    "@type": "CreativeWork",
    "url": "https://apify.com/techforce.global/quince-scraper"
  },
  "keywords": "Quince scraper, Quince.com product data, price monitoring, discount tracking, competitor price scraping, e-commerce product data, review scraping, retail price comparison, MCP connector"
}
```

```json
{
    "@context": "https://schema.org/",
    "@type": "FAQPage",
    "mainEntity": [
        {
            "@type": "Question",
            "name": "Do I need a Quince account or API key?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. The Actor reads publicly available product pages. You need an Apify account and API token; you need no Quince credentials whatsoever."
            }
        },
        {
            "@type": "Question",
            "name": "Is this an official Quince API?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Quince publishes no public product API. This is an independent Actor and is not affiliated with, endorsed by, or sponsored by Quince."
            }
        },
        {
            "@type": "Question",
            "name": "Do I need to configure proxies?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Yes - keep the residential proxy on. Quince sits behind Cloudflare, and the homepage probe fails fast with a clear message when a challenge is served. Residential groups require a paid Apify plan."
            }
        },
        {
            "@type": "Question",
            "name": "Can I plug it into Claude, Cursor, or a LangChain agent?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Yes - it is a native MCP tool. Add it with: claude mcp add --transport http apify \"https://mcp.apify.com/?tools=techforce.global/quince-scraper\""
            }
        },
        {
            "@type": "Question",
            "name": "Which mode should I use?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "product_urls when you already know the SKUs, category to sweep a section, fuzzy_search for free-text intent. One mode per run."
            }
        },
        {
            "@type": "Question",
            "name": "Why did I only get ~30 products from a category?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Category mode reads a single listing page and takes the products embedded in its server-rendered payload - there is no pagination. categoryMaxProducts caps that number; it cannot raise it. Use several narrower slugs, or supply product URLs."
            }
        },
        {
            "@type": "Question",
            "name": "Can I scrape several categories or queries in one run?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No - one mode and one query or category per run. Loop the Actor in your orchestration layer."
            }
        },
        {
            "@type": "Question",
            "name": "Can I get Canadian or other non-US pricing?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. region accepts US only - every request goes to the US storefront at www.quince.com and all prices are USD. Setting the Apify proxy country to another country does not change the storefront."
            }
        },
        {
            "@type": "Question",
            "name": "Why is everything \"N/A\" instead of null?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "By design - the extractor emits the string N/A for any missing value so downstream code never has to guard against null. The trade-off: images and reviews are also the string N/A when absent, so type-check before iterating."
            }
        },
        {
            "@type": "Question",
            "name": "Why only 5 reviews?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "The Actor returns the 5 most recent reviews per product, plus averageRating and total reviewCount for the full picture."
            }
        },
        {
            "@type": "Question",
            "name": "Are reviewer emails included?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Author handles that look like email addresses are masked before being written - the local part is truncated and the domain is replaced entirely."
            }
        },
        {
            "@type": "Question",
            "name": "Do I get stock levels or size/colour variants?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Only the fields listed in the Output Contract, and images for the primary colour only."
            }
        },
        {
            "@type": "Question",
            "name": "What is the MCP connector for?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "It pushes the scraped products straight into a tool you have already authorized on your Apify account - Notion, Slack, Google Sheets, Airtable, Linear, or any MCP-compatible connector - with no glue code. Credentials stay private: delivery runs through the Apify MCP Proxy, so the Actor never sees your connector tokens."
            }
        },
        {
            "@type": "Question",
            "name": "Which delivery mode should I use?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "summary for a digest, chunked for long lists into services with request caps such as Notion, perProduct for row-per-product targets such as Sheets or Airtable, none for dataset-only runs."
            }
        },
        {
            "@type": "Question",
            "name": "Does delivery work when running locally?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Connectors resolve through the Apify MCP Proxy, which only exists on the platform. Locally you will see APIFY_MCP_PROXY_URL is not set and the dataset is saved as normal."
            }
        },
        {
            "@type": "Question",
            "name": "What does it cost?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "From $0.015 per product - $15.00 per 1,000 results on the entry tier, less on higher subscription tiers. Apify platform usage is billed separately. No monthly subscription."
            }
        },
        {
            "@type": "Question",
            "name": "How do I guarantee an agent never overspends?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Pass maxTotalChargeUsd as a query parameter on the run endpoint. It is a hard per-execution ceiling - the run stops rather than exceeding it."
            }
        }
    ]
}
```

# Actor input Schema

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

How you want to tell the actor what to scrape.

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

Free-text query, e.g. "mongolian cashmere crewneck". Used only when mode = fuzzy\_search.

## `searchLimit` (type: `integer`):

Cap on products returned by the fuzzy search. Used only when mode = fuzzy\_search.

## `category` (type: `string`):

Pick from Quince's mega-menu. Refreshed via scripts/fetch\_categories.py. Used only when mode = category.

## `categoryMaxProducts` (type: `integer`):

Cap on products scraped from the chosen category. Used only when mode = category.

## `productUrls` (type: `array`):

One or more full PDP URLs to scrape. Used only when mode = product\_urls.

## `region` (type: `string`):

Quince storefront region. Only the US storefront (www.quince.com) is supported, so all prices are USD.

## `proxy` (type: `object`):

Apify Proxy settings. RESIDENTIAL is recommended. If you hit proxy tunnel failures during a run, try a different country (e.g. US -> CA) or a different proxy group, then re-run.

## `maxConcurrency` (type: `integer`):

Maximum parallel HTTP requests.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed network request before giving up.

## `mcpConnector` (type: `string`):

Optionally deliver the scraped products into a connector you have authorized - Notion, Slack, Airtable, Google Sheets, Linear, or any MCP-compatible connector. Leave empty to only save results to the dataset.

## `deliveryMode` (type: `string`):

How to deliver to the connector: 'summary' (one call with all scraped products), 'chunked' (split a long product list across a few calls so services like Notion never time out), 'perProduct' (one call per product), or 'none' (save to dataset only).

## `mcpTool` (type: `string`):

Name of the tool to call on the connector (e.g. 'create\_page' for Notion, 'send\_message' for Slack, 'append\_row' for Google Sheets/Airtable). If unsure, run once with a connector selected - the log lists the connector's available tools.

## `mcpArguments` (type: `object`):

Arguments passed to the connector tool. String values support {placeholders}. In 'summary'/'chunked' modes: {mode}, {sourceInput}, {productCount}, {productsText} (formatted product list, or one part of it in chunked mode), {part}/{partCount} (chunked mode only), and {message} (the rendered template below). In 'perProduct' mode: {title}, {url}, {description}, {sellingPrice}, {retailPrice}, {discount}, {averageRating}, {reviewCount}, {imageUrl}, {productText} (one formatted product block), and {message}. Example for Slack: {"channel": "#deals", "text": "{message}"}.

## `mcpMessageTemplate` (type: `string`):

Optional template rendered and exposed as the {message} placeholder in the tool arguments. Summary example: 'Found {productCount} Quince products for {sourceInput}:

{productsText}'. Per-product example: '{title} - {sellingPrice} (was {retailPrice}, {discount} off)
{url}'.

## Actor input object example

```json
{
  "mode": "fuzzy_search",
  "searchQuery": "mongolian cashmere crewneck",
  "searchLimit": 50,
  "category": "/women/sweaters",
  "categoryMaxProducts": 200,
  "productUrls": [],
  "region": "US",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 10,
  "maxRequestRetries": 3,
  "deliveryMode": "summary",
  "mcpTool": "",
  "mcpArguments": {},
  "mcpMessageTemplate": ""
}
```

# Actor output Schema

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

Extracted Quince product records (one item per product).

# 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 = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("techforce.global/quince-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 = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    } }

# Run the Actor and wait for it to finish
run = client.actor("techforce.global/quince-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 '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call techforce.global/quince-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,techforce.global/quince-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/3JHxcRV7Q1QeqRWGi/builds/XitbgnPIgYDaRfroW/openapi.json