# Etsy Listings Extractor (`kawsar/etsy-listings-extractor`) Actor

Etsy Listings Extractor pulls product listings from any Etsy search, category, or shop page, so you get titles, prices, sale prices, ratings, reviews, shop names, and links ready for SEO and pricing research.

- **URL**: https://apify.com/kawsar/etsy-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** E-commerce, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Etsy Listings Extractor

Etsy Listings Extractor pulls product listings off any Etsy search, category, or shop page. Give it a keyword or paste a page URL, and it returns each listing with its title, price, sale price, star rating, reviews, shop name, image, and a direct link. Good for SEO research, price tracking, product sourcing, and keeping an eye on the competition.

### What it does

Etsy shows listings in a grid on search pages, category pages, and shop pages. This actor reads that grid and turns every listing into a clean row of data you can sort, filter, and export. No login, no manual copy and paste.

Everything comes from the results grid in a single pass. The actor does not open each listing separately, so runs stay fast and cheap.

For each listing you get:

- Listing ID and title
- Current price and currency
- Original list price, sale flag, and discount percent
- Star rating and review count
- Star Seller, free shipping, and ad flags
- Shop name
- Product image and the direct listing URL
- The source page and the time it was scraped

### Use cases

- Track how competitors price similar products and spot sales as they happen
- Check which listings rank on the first page for a keyword you care about
- Source products by browsing a category and pulling the whole grid at once
- Build a research sheet of titles, tags, and prices for SEO and market analysis

### Input

You can start from keywords, from URLs, or both. Provide at least one.

| Field | Type | Description |
|-------|------|-------------|
| `startUrls` | array of strings | Etsy search, category, or shop URLs to read directly. |
| `searchTerms` | array of strings | Keywords to search on Etsy. Each one becomes a search. |
| `maxItems` | integer | Total listings to collect per URL or keyword. Default 50, up to 1000. |
| `requestTimeoutSecs` | integer | Per-request timeout in seconds. Default 60. |

#### Example input

```json
{
    "searchTerms": ["leather wallet", "personalized gift"],
    "startUrls": ["https://www.etsy.com/c/clothing"],
    "maxItems": 200
}
````

### Output

Each listing is saved as one item in the dataset. Example:

```json
{
    "listingId": "1311518839",
    "title": "Moc Toe Orange Shoes Classic Oxford Heritage Style Boots",
    "url": "https://www.etsy.com/listing/1311518839/moc-toe-orange-shoes-classic-oxford",
    "price": 290.0,
    "currency": "USD",
    "listPrice": 322.22,
    "onSale": true,
    "discountPercent": 10,
    "availability": "InStock",
    "rating": 5.0,
    "reviewCount": 48,
    "isStarSeller": true,
    "freeShipping": true,
    "isAd": false,
    "shopName": "HeritageLeatherCo",
    "image": "https://i.etsystatic.com/16179351/r/il/b11676/4238221167/il_340x270.jpg",
    "sourceUrl": "https://www.etsy.com/c/clothing",
    "scrapedAt": "2026-07-13T10:00:00+00:00"
}
```

Export the dataset as JSON, CSV, or Excel from the run's Storage tab, or pull it through the Apify API.

### Pagination

You do not need to add page numbers yourself. Give the actor a search URL or a keyword, set `maxItems`, and it follows Etsy's pages until it has collected that many listings (or runs out of results). `maxItems` is applied per URL or keyword, so three keywords at `maxItems` 50 can return up to 150 listings.

### What data is available

Every field is read from the results grid, so what you get depends on what Etsy shows there:

- Search pages include the shop name, price, sale price, and discount. Etsy loads ratings on search pages inconsistently, so some rows may have no rating.
- Category and shop pages reliably include ratings, review counts, and badges like Star Seller and free shipping.
- A `null` value means Etsy did not show that field on the page, not that extraction failed. Title, price, image, and the listing URL are always present.

For ratings on every listing, use category or shop URLs rather than search keywords. Those pages include ratings on the first load.

### Notes

- Be considerate with how often you run large jobs so you stay within Etsy's terms of use.
- Deeper pagination means more requests. Keep `maxItems` sensible if you are running many keywords at once.

# Actor input Schema

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

Etsy search, category, or shop URLs to extract listings from. Paste any page that shows a grid of listings. The actor pages through results automatically.

## `searchTerms` (type: `array`):

Keywords to search on Etsy. Each keyword is turned into a search and its listings are extracted. Optional if you already provide URLs above.

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

Total listings to collect from each URL or keyword. The actor follows pagination until it reaches this many. This is a per-URL total, not a per-page limit, so three keywords at 50 return up to 150 listings.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds. Protected pages can take 20 to 40 seconds to load.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.etsy.com/search?q=handmade+jewelry"
  ],
  "searchTerms": [
    "personalized gift",
    "ceramic mug"
  ],
  "maxItems": 10,
  "requestTimeoutSecs": 60
}
```

# 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 = {
    "startUrls": [
        "https://www.etsy.com/search?q=leather+wallet"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/etsy-listings-extractor").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 = { "startUrls": ["https://www.etsy.com/search?q=leather+wallet"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/etsy-listings-extractor").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 '{
  "startUrls": [
    "https://www.etsy.com/search?q=leather+wallet"
  ]
}' |
apify call kawsar/etsy-listings-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Listings Extractor",
        "description": "Etsy Listings Extractor pulls product listings from any Etsy search, category, or shop page, so you get titles, prices, sale prices, ratings, reviews, shop names, and links ready for SEO and pricing research.",
        "version": "0.0",
        "x-build-id": "G9be3xOgzx5rgMVkQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~etsy-listings-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-etsy-listings-extractor",
                "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/kawsar~etsy-listings-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-etsy-listings-extractor",
                "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/kawsar~etsy-listings-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-etsy-listings-extractor",
                "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": {
                    "startUrls": {
                        "title": "Etsy page URLs",
                        "type": "array",
                        "description": "Etsy search, category, or shop URLs to extract listings from. Paste any page that shows a grid of listings. The actor pages through results automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on Etsy. Each keyword is turned into a search and its listings are extracted. Optional if you already provide URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per URL",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Total listings to collect from each URL or keyword. The actor follows pagination until it reaches this many. This is a per-URL total, not a per-page limit, so three keywords at 50 return up to 150 listings.",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Protected pages can take 20 to 40 seconds to load.",
                        "default": 60
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
