# Etsy Scraper — Products, Prices, Reviews & Shop Data (`khadinakbar/etsy-all-in-one-scraper`) Actor

Scrape Etsy product listings, prices, ratings, seller info, Star Seller & Bestseller badges, materials, tags, shop catalogs & customer reviews. Filter by category, price range, free shipping, or sale status. No API key or login needed.

- **URL**: https://apify.com/khadinakbar/etsy-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, SEO tools
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 etsy product extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Etsy Scraper — Extract Products, Prices, Reviews & Shop Data

**The most complete Etsy scraper on Apify.** Search by keyword, scrape full shop catalogs, or extract individual product pages — all in one actor. No Etsy API key required. No login. Just clean, structured JSON ready for analysis, AI pipelines, or spreadsheets.

---

### What does this Etsy scraper do?

This actor extracts structured data from Etsy's marketplace: product listings from search results, full product detail pages with descriptions and variations, complete shop catalogs, and customer reviews — all in a single run.

Unlike Etsy scrapers that only handle one input type, this actor accepts **search keywords**, **direct product URLs**, and **shop URLs** simultaneously, returning a clean consistent dataset with the same field structure regardless of source.

**Handles all three Etsy input types:**

- **Etsy keyword search** — type any search term, get paginated product listings just like Etsy search results
- **Etsy product page scraper** — paste a listing URL to get the full product data including description, tags, and all image URLs
- **Etsy shop scraper** — paste a shop URL to extract the entire catalog with pagination

---

### Why choose this Etsy data extractor?

#### More data fields than any competitor

In full detail mode you get the complete product page: descriptions, materials list, all image URLs, size/color/style variations, processing time, shipping origin, and seller tags. Most Etsy scrapers return only listing-level data (title, price, thumbnail) — this actor goes deeper.

#### Badge detection

Know which listings carry **Star Seller**, **Bestseller**, and **Etsy's Pick** badges. These badges are key signals for competitor research, product validation, and trend spotting that most scrapers miss entirely.

#### Reviews included

Toggle on customer review scraping to get star ratings, review text, and reviewer names alongside product data — all in the same dataset, no second run needed.

#### Advanced filtering

Filter results by category, price range (min/max), free shipping status, or sale status — before data is returned, so you're only paying for records you actually want.

#### MCP and AI-agent ready

Full typed output schema means Claude, ChatGPT Operator, n8n, and other AI agents can consume your Etsy data immediately with zero manual wrangling. Works natively with Apify's MCP server.

---

### What data does the Etsy scraper extract?

| Field | Description | Available In |
|---|---|---|
| `listing_id` | Unique Etsy listing ID | All modes |
| `title` | Full product title | All modes |
| `url` | Product page URL | All modes |
| `price` | Current price (number, sale price if discounted) | All modes |
| `original_price` | Pre-discount price (null if not on sale) | All modes |
| `currency` | Three-letter currency code | All modes |
| `is_on_sale` | Whether the item is discounted | All modes |
| `rating` | Average star rating out of 5 | All modes |
| `review_count` | Total customer review count | All modes |
| `num_favorers` | Number of favourites / hearts | All modes |
| `shop_name` | Seller shop name | All modes |
| `shop_url` | Link to seller's Etsy shop | All modes |
| `shop_location` | Seller's country/region | All modes |
| `shop_sales_count` | Total shop sales | All modes |
| `thumbnail_url` | Main listing thumbnail image URL | All modes |
| `is_free_shipping` | Whether free shipping is offered | All modes |
| `badge_star_seller` | Has Etsy Star Seller badge | All modes |
| `badge_bestseller` | Has Bestseller badge | All modes |
| `badge_etsy_pick` | Has Etsy's Pick badge | All modes |
| `images` | All product image URLs | Detail mode |
| `description` | Full product description text | Detail mode |
| `materials` | Materials list | Detail mode |
| `tags` | Seller SEO tags | Detail mode |
| `variations` | Size / color / style options | Detail mode |
| `shipping_from` | Ships-from country | Detail mode |
| `processing_time` | Estimated production & prep time | Detail mode |
| `review_id` | Unique review ID | Review mode |
| `review_rating` | Individual review star rating | Review mode |
| `review_text` | Review body text | Review mode |
| `reviewer_name` | Reviewer display name | Review mode |
| `review_date` | Review submission date | Review mode |
| `scrape_mode` | How this record was collected | All modes |
| `scraped_at` | ISO 8601 extraction timestamp | All modes |
| `source_url` | URL scraped to produce this record | All modes |

---

### How to scrape Etsy — step-by-step

#### 1. Keyword search (fastest, cheapest)

Enter one or more keywords in **Search Keywords**. The actor runs an Etsy search for each keyword and paginates through results pages until `maxResults` is reached.

```json
{
  "searchQueries": ["handmade necklace", "vintage ceramic mug"],
  "maxResults": 200,
  "sortOrder": "most_relevant"
}
````

#### 2. Direct Etsy URLs (most precise)

Paste any Etsy URL into **Etsy URLs**. The actor auto-detects whether it's a search results page, product listing page, or shop page and handles each correctly.

```json
{
  "startUrls": [
    { "url": "https://www.etsy.com/shop/MoonCraftStudio" },
    { "url": "https://www.etsy.com/listing/1234567890/silver-ring" }
  ],
  "includeProductDetails": true
}
```

#### 3. Full product detail scrape (richest data)

Enable **Include Full Product Details** to visit each product page and collect descriptions, materials, tags, variations, and all images. This makes runs slower because each listing gets its own page visit.

```json
{
  "searchQueries": ["boho jewelry"],
  "maxResults": 50,
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviewsPerProduct": 25
}
```

#### 4. Filter before you pay

Use price range, category, free shipping, and on-sale filters so you only extract records you actually need:

```json
{
  "searchQueries": ["handmade ring"],
  "category": "jewelry-and-accessories",
  "sortOrder": "lowest_price",
  "minPrice": 10,
  "maxPrice": 50,
  "freeShippingOnly": true,
  "onSaleOnly": false,
  "maxResults": 500
}
```

***

### Pricing

This actor uses **pay-per-event pricing** at **$0.003 per extracted record**.

| Results | Estimated Cost |
|---|---|
| 100 results | ~$0.30 |
| 500 results | ~$1.50 |
| 1,000 results | ~$3.00 |
| 5,000 results | ~$15.00 |

A small platform fee (based on memory usage and run duration) is also charged per run. Use the `maxResults` cap to control spend precisely — the actor stops exactly when the limit is reached.

> **Cost tip:** Run in listing-only mode (default) for the cheapest rate. Enable `includeProductDetails` only when you need rich product-page data — it uses more compute per record.

***

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string\[] | — | Keywords to search on Etsy |
| `startUrls` | URL\[] | — | Direct Etsy URLs (search, product, or shop) |
| `maxResults` | integer | 50 | Maximum total records to extract |
| `category` | string | all | Filter by Etsy category |
| `sortOrder` | string | most\_relevant | Sort by relevance, price, or date listed |
| `minPrice` | number | — | Minimum price filter (USD) |
| `maxPrice` | number | — | Maximum price filter (USD) |
| `freeShippingOnly` | boolean | false | Only return free-shipping products |
| `onSaleOnly` | boolean | false | Only return products currently on sale |
| `includeProductDetails` | boolean | false | Visit each product page for full details |
| `includeReviews` | boolean | false | Scrape customer reviews per product |
| `maxReviewsPerProduct` | integer | 10 | Max reviews per listing (requires `includeReviews`) |
| `proxyConfiguration` | object | Residential | Proxy settings (residential strongly recommended) |

***

### Output format

Results are pushed to the default Apify dataset. Each record is a flat JSON object — all fields are always present, with `null` for data not available in the current scrape mode. The `scrape_mode` field tells you how each record was collected.

**Sample listing record (default mode):**

```json
{
  "listing_id": "1234567890",
  "title": "Handmade Silver Moonstone Ring — Boho Gift for Her",
  "url": "https://www.etsy.com/listing/1234567890/handmade-silver-moonstone-ring",
  "price": 34.99,
  "original_price": null,
  "currency": "USD",
  "is_on_sale": false,
  "rating": 4.8,
  "review_count": 312,
  "num_favorers": 1847,
  "shop_name": "MoonCraftStudio",
  "shop_url": "https://www.etsy.com/shop/MoonCraftStudio",
  "shop_location": "United States",
  "shop_sales_count": 4821,
  "thumbnail_url": "https://i.etsystatic.com/...",
  "images": null,
  "is_free_shipping": true,
  "badge_star_seller": true,
  "badge_bestseller": false,
  "badge_etsy_pick": false,
  "description": null,
  "materials": null,
  "tags": null,
  "variations": null,
  "shipping_from": null,
  "processing_time": null,
  "scrape_mode": "listing",
  "scraped_at": "2026-04-09T12:30:00.000Z",
  "source_url": "https://www.etsy.com/search?q=handmade+necklace"
}
```

***

### Use cases

**Etsy market research & trend analysis**
Discover trending handmade and vintage products. Track what's bestselling across a niche, which badge types dominate search results, and how pricing is distributed by category. Build datasets to identify seasonal demand patterns.

**Etsy competitor analysis**
Scrape a competitor's entire shop catalog. Analyse their tags, materials, pricing strategy, review velocity, and Star Seller status. Find the gaps in their catalog you can capitalise on.

**Etsy price monitoring**
Schedule recurring runs to track price changes over time. Alert when competitors run sales, restock, or add new listings. Build historical price datasets for Amazon-style tracking.

**Etsy SEO keyword research**
Collect the titles and seller tags that top-ranking listings use in your niche. Extract and analyse the most common keywords, phrases, and material descriptors across hundreds of bestsellers to optimise your own listings.

**Etsy product sourcing & supplier research**
Find prolific shops and wholesale suppliers in specific categories. Filter by Star Seller badge and review count as quality signals. Export shop contact data for outreach.

**AI and LLM pipelines**
Feed structured Etsy product data directly into Claude, GPT-4o, or any AI agent via the Apify MCP server for automated competitive analysis, product description generation, or trend summarisation.

**Sentiment analysis from Etsy reviews**
Export thousands of customer reviews across a niche to train classifiers, extract product improvement insights, or identify recurring complaints and praise patterns.

***

### Run via API

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/etsy-all-in-one-scraper').call({
  searchQueries: ['handmade jewelry', 'vintage lamp'],
  maxResults: 500,
  includeProductDetails: true,
  sortOrder: 'most_relevant',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} Etsy products`);
```

Schedule runs, export to Google Sheets, connect to Zapier or Make, or trigger from n8n workflows using Apify's built-in integrations.

***

### FAQ

**Does this Etsy scraper require an API key or Etsy account?**
No. It scrapes Etsy's public pages only. No login, no API key, no account required.

**Does it work for all Etsy categories?**
Yes — jewelry, clothing, home & living, vintage, art, craft supplies, and all other Etsy categories are supported.

**Why do I need residential proxies?**
Etsy uses anti-bot protection (DataDome) that blocks datacenter IP ranges. Residential proxies rotate through real ISP addresses, making requests indistinguishable from regular browser traffic. The actor defaults to Apify's residential proxy pool for maximum reliability.

**What's the difference between listing mode and detail mode?**
Listing mode (default) extracts data directly from search result pages — fast and cheap, returns ~20 core fields. Detail mode visits each listing's individual page to add description, materials, tags, all images, and variations — slower and more expensive per record, but returns ~30+ fields.

**Can I scrape an entire Etsy shop?**
Yes. Paste the shop URL (e.g. `https://www.etsy.com/shop/ShopName`) into **Etsy URLs**. The actor paginates through the shop's full catalog automatically.

**Can I scrape Etsy reviews?**
Yes. Enable `includeReviews: true` (requires `includeProductDetails: true`). Reviews are returned as separate records in the same dataset with `scrape_mode: "review"`.

**Why do some fields return null?**
Fields like `description`, `materials`, `tags`, and `images` only appear on individual product pages. In listing mode (reading from search result pages), these fields are unavailable and return `null`. Enable `includeProductDetails` to populate them.

**How many results can I scrape?**
Up to 5,000 results per run. For larger datasets, schedule multiple runs with pagination or different keyword sets.

***

### Works great with

- **Apify Google Sheets Integration** — export results directly to a Google Sheet for filtering and sharing
- **Apify Scheduler** — run on a recurring schedule to build historical pricing and trend datasets
- **Apify MCP Server** — query your Etsy data from Claude, ChatGPT Operator, or any MCP-compatible AI agent
- **Make / Zapier** — trigger Etsy scrapes and route output to any tool in your stack

***

### Legal disclaimer

This actor is intended for lawful extraction of publicly available data from Etsy's marketplace. Users are responsible for ensuring their use complies with Etsy's Terms of Service, applicable data protection regulations (GDPR, CCPA, etc.), and all relevant laws in their jurisdiction. The actor does not bypass authentication, access private data, or perform actions on behalf of any user account.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this field when the user provides keywords or product names to search (e.g. 'handmade necklace', 'vintage lamp'). Each keyword becomes a separate Etsy search. Do NOT use this when the user provides a specific Etsy URL — use startUrls instead.

## `startUrls` (type: `array`):

Use this field when the user provides specific Etsy URLs. Supports search result pages (etsy.com/search?q=...), product pages (etsy.com/listing/ID/...), and shop pages (etsy.com/shop/ShopName). Do NOT use this for keyword searches — use searchQueries instead.

## `maxResults` (type: `integer`):

Maximum number of results to extract total. For search queries, this is split across all queries. Default: 50.

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

Filter search results to a specific Etsy category. Leave empty to search all categories.

## `sortOrder` (type: `string`):

How to sort Etsy search results.

## `minPrice` (type: `number`):

Only return products priced at or above this value in USD.

## `maxPrice` (type: `number`):

Only return products priced at or below this value in USD.

## `freeShippingOnly` (type: `boolean`):

When enabled, only returns products that offer free shipping.

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

When enabled, only returns products currently on sale with a discounted price.

## `includeProductDetails` (type: `boolean`):

When enabled, visits each product page to extract full description, materials list, tags, all images, variations (size/color options), shipping origin, and processing time. Slower but much richer data. Recommended for product research and competitor analysis.

## `includeReviews` (type: `boolean`):

When enabled, scrapes customer reviews for each product. Requires includeProductDetails to be enabled. Use this for sentiment analysis, customer feedback research, and quality assessment.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to scrape per product listing. Only applies when includeReviews is enabled.

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

Proxy settings. Residential proxies are strongly recommended for Etsy — datacenter proxies get blocked. Defaults to Apify residential proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "handmade necklace"
  ],
  "startUrls": [],
  "maxResults": 20,
  "category": "",
  "sortOrder": "most_relevant",
  "freeShippingOnly": false,
  "onSaleOnly": false,
  "includeProductDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `datasetId` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "handmade necklace"
    ],
    "startUrls": [],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/etsy-all-in-one-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["handmade necklace"],
    "startUrls": [],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/etsy-all-in-one-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "handmade necklace"
  ],
  "startUrls": [],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/etsy-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Scraper — Products, Prices, Reviews & Shop Data",
        "description": "Scrape Etsy product listings, prices, ratings, seller info, Star Seller & Bestseller badges, materials, tags, shop catalogs & customer reviews. Filter by category, price range, free shipping, or sale status. No API key or login needed.",
        "version": "1.0",
        "x-build-id": "XAsIRUJk3PnpTHwMP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~etsy-all-in-one-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-etsy-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~etsy-all-in-one-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-etsy-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~etsy-all-in-one-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-etsy-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Use this field when the user provides keywords or product names to search (e.g. 'handmade necklace', 'vintage lamp'). Each keyword becomes a separate Etsy search. Do NOT use this when the user provides a specific Etsy URL — use startUrls instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Etsy URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific Etsy URLs. Supports search result pages (etsy.com/search?q=...), product pages (etsy.com/listing/ID/...), and shop pages (etsy.com/shop/ShopName). Do NOT use this for keyword searches — use searchQueries instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of results to extract total. For search queries, this is split across all queries. Default: 50.",
                        "default": 50
                    },
                    "category": {
                        "title": "Category Filter",
                        "enum": [
                            "",
                            "jewelry-and-accessories",
                            "clothing-and-shoes",
                            "home-and-living",
                            "wedding-and-party",
                            "toys-and-entertainment",
                            "art-and-collectibles",
                            "craft-supplies-and-tools",
                            "vintage",
                            "gifts",
                            "electronics-and-accessories",
                            "bags-and-purses",
                            "bath-and-beauty"
                        ],
                        "type": "string",
                        "description": "Filter search results to a specific Etsy category. Leave empty to search all categories.",
                        "default": ""
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "most_relevant",
                            "lowest_price",
                            "highest_price",
                            "recently_listed"
                        ],
                        "type": "string",
                        "description": "How to sort Etsy search results.",
                        "default": "most_relevant"
                    },
                    "minPrice": {
                        "title": "Min Price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return products priced at or above this value in USD."
                    },
                    "maxPrice": {
                        "title": "Max Price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return products priced at or below this value in USD."
                    },
                    "freeShippingOnly": {
                        "title": "Free Shipping Only",
                        "type": "boolean",
                        "description": "When enabled, only returns products that offer free shipping.",
                        "default": false
                    },
                    "onSaleOnly": {
                        "title": "On Sale Only",
                        "type": "boolean",
                        "description": "When enabled, only returns products currently on sale with a discounted price.",
                        "default": false
                    },
                    "includeProductDetails": {
                        "title": "Include Full Product Details",
                        "type": "boolean",
                        "description": "When enabled, visits each product page to extract full description, materials list, tags, all images, variations (size/color options), shipping origin, and processing time. Slower but much richer data. Recommended for product research and competitor analysis.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include Product Reviews",
                        "type": "boolean",
                        "description": "When enabled, scrapes customer reviews for each product. Requires includeProductDetails to be enabled. Use this for sentiment analysis, customer feedback research, and quality assessment.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews Per Product",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product listing. Only applies when includeReviews is enabled.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are strongly recommended for Etsy — datacenter proxies get blocked. Defaults to Apify residential proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
