# Etsy Store Scraper (`akash9078/etsy-store-scraper`) Actor

Scrapes product data from Etsy stores including titles, prices, images, ratings, and reviews.

- **URL**: https://apify.com/akash9078/etsy-store-scraper.md
- **Developed by:** [Akash Kumar Naik](https://apify.com/akash9078) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 34 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

from $0.00005 / actor start

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/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

## Etsy Store Scraper - Extract Etsy Store Data with Images

Effortlessly scrape detailed product information from Etsy including prices, images, and seller details. Our powerful Etsy store scraper bypasses anti-bot measures to extract accurate, structured data for market research, price monitoring, and competitor analysis.

### Key Features

- **Comprehensive Data Extraction**: Get product titles, descriptions, prices, images, and seller info
- **Anti-Detection Technology**: Overcomes Etsy's bot protection using Camoufox browser
- **Rich Media Collection**: Extract all product images in high quality
- **Flexible Configuration**: Adjustable item limits, proxy settings
- **Structured Output**: Clean JSON data ready for analysis or integration
- **Residential Proxy Support**: Built-in residential proxy for reliable scraping
- **Pay-Per-Event Pricing**: Transparent, usage-based pricing model

### Use Cases

- **Market Research**: Analyze product trends, pricing strategies, and seller performance
- **Price Monitoring**: Track competitor pricing and automate repricing strategies
- **Catalog Building**: Create comprehensive product databases for affiliate marketing
- **Inventory Tracking**: Monitor product availability and seller inventory changes
- **Competitor Analysis**: Compare product offerings and features

### Input Parameters

#### Required

- **shopName**: Etsy shop name (e.g., "yesintelligent")

#### Optional

- **maxItems**: Maximum number of items to scrape (0 = no limit, default: 100)
- **proxyConfig**: Proxy configuration for IP rotation
  - `useApifyProxy`: Use Apify's proxy network (default: true)
  - `apifyProxyGroups`: Proxy groups to use (default: \["RESIDENTIAL"])
  - `apifyProxyCountry`: Proxy country code (default: "GB")
- **geoipConfig**: GeoIP configuration for browser fingerprint matching
  - `enabled`: Enable GeoIP spoofing (default: true)
  - `autoDetect`: Automatically detect location from proxy IP (default: true)
  - `timezone`: Manual timezone override (e.g., "Europe/London")
  - `locale`: Manual locale override (e.g., "en-GB")
  - `lat`: Manual latitude for geolocation
  - `lon`: Manual longitude for geolocation

#### GeoIP Configuration Examples

**Automatic Detection (Recommended):**

```json
{
  "shopName": "exampleshop",
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyCountry": "GB"
  },
  "geoipConfig": {
    "enabled": true,
    "autoDetect": true
  }
}
```

**Manual Location Override:**

```json
{
  "shopName": "exampleshop",
  "geoipConfig": {
    "enabled": true,
    "autoDetect": false,
    "timezone": "Europe/London",
    "locale": "en-GB",
    "lat": 51.5074,
    "lon": -0.1278
  }
}
```

### Output Data Format

```json
{
  "title": "Handmade Ceramic Mug",
  "sellerName": "Artisan Pottery Shop",
  "shopUrl": "https://www.etsy.com/uk/shop/ArtisanPotteryShop",
  "price": "24.99",
  "currency": "USD",
  "images": ["https://image1.jpg/", "https://image2.jpg/"],
  "scrapedUrl": "https://www.etsy.com/uk/listing/12345/handmade-ceramic-mug",
  "scrapedAt": "2025-01-15T10:30:00.000Z",
  "status": "success"
}
```

### Pricing - Pay-Per-Event Model

This actor uses Apify's **Pay-Per-Event (PPE)** pricing model for transparent, usage-based costs:

| Event | Price | Description |
|-------|-------|-------------|
| `apify-actor-start` | $0.005 | Charged once when the Actor starts |
| `apify-default-dataset-item` | $0.002 | Charged for each product successfully scraped |
| `page-loaded` | $0.02 | Charged for each shop page loaded during pagination |

#### Example Cost Calculation

Scraping a shop with 200 products across 6 pages:

- Actor start: 1 × $0.005 = **$0.005**
- Pages loaded: 6 × $0.02 = **$0.12**
- Products scraped: 200 × $0.002 = **$0.40**
- **Total: $0.525**

Users can set a **maximum spending limit** per run in the Apify Console. The actor automatically respects this limit and stops when reached.

### Getting Started

#### Via Apify Platform

1. Visit the actor page on Apify
2. Click "Try for free" or "Run"
3. Enter the Etsy shop name
4. Configure settings and run
5. Download results as JSON, CSV, or Excel

#### Via API

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_USERNAME~etsy-store-scraper/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "shopName": "yesintelligent",
    "maxItems": 50,
    "proxyConfig": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "GB"
    }
  }'
```

### Technical Details

#### Anti-Detection Features

- Uses **Camoufox** browser for advanced fingerprint masking
- Simulates human behavior with random delays
- Residential proxies prevent IP blocking
- UK-based proxy recommended for `etsy.com/uk` URLs

#### Pagination Support

- Automatically handles multi-page shops
- Supports unlimited scraping (set `maxItems: 0`)
- Respects rate limits to avoid detection

#### Memory Configuration

- Minimum memory: 512 MB
- Maximum memory: 2048 MB
- Auto-scales based on requirements

### Best Practices

#### For Users

1. **Set spending limits**: Use the max charge limit in Apify Console to control costs
2. **Use residential proxies**: Essential for reliable Etsy scraping
3. **Start small**: Test with `maxItems: 10` before large scrapes
4. **Off-peak scraping**: Run during off-peak hours for better reliability
5. **Handle errors**: Check the output for error records with `status: "error"`

#### For Developers

1. **Local testing with PPE**:
   ```bash
   ACTOR_TEST_PAY_PER_EVENT=true npm start
   ```

2. **View charging log locally**:
   ```bash
   ACTOR_TEST_PAY_PER_EVENT=true ACTOR_USE_CHARGING_LOG_DATASET=true npm start
   ```
   The charging log will be available in `storage/datasets/charging_log/`

3. **Backward compatibility**: The actor supports both PPE and PPR (Pay-Per-Result) pricing models automatically

4. **Respect user limits**: The `Actor.charge()` method automatically enforces user-configured spending limits

5. **Idempotency**: Each charge is idempotent when using the Apify SDK

### Output Schemas

The actor provides structured output through:

- **Dataset**: All scraped products with the schema defined in `DATASET_SCHEMA.json`
- **Key-Value Store**: Run summary stored as `OUTPUT` record
- **Output Schema**: Links to both dataset and summary via `OUTPUT_SCHEMA.json`

### Troubleshooting

| Issue | Solution |
|-------|----------|
| "Could not load shop page" | Verify shop name exists; check proxy configuration |
| No products found | Shop may be empty or have anti-scraping enabled |
| Timeout errors | Increase `maxItems` or use better proxies |
| High costs | Set a max charge limit in the Console |

### Support

For issues or feature requests, please contact the actor developer or visit the Apify support center.

***

**Start scraping Etsy store data today with transparent, pay-per-event pricing!**

# Actor input Schema

## `shopName` (type: `string`):

Enter the name of the Etsy shop to scrape products from

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

Maximum number of items to scrape (0 = no limit)

## `proxyConfig` (type: `object`):

Configure proxies to avoid IP blocking. Using UK-based residential proxies is recommended for scraping UK Etsy sites.

## Actor input object example

```json
{
  "shopName": "yesintelligent",
  "maxItems": 5,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# Actor output Schema

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

All scraped products from the Etsy store

## `summary` (type: `string`):

Summary of the scraping run including statistics

# 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 = {
    "shopName": "yesintelligent",
    "maxItems": 5,
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("akash9078/etsy-store-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 = {
    "shopName": "yesintelligent",
    "maxItems": 5,
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("akash9078/etsy-store-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 '{
  "shopName": "yesintelligent",
  "maxItems": 5,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call akash9078/etsy-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,akash9078/etsy-store-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/QuvcTPrXVRZk8OtfX/builds/LJSwdJLJ0GntbhoNH/openapi.json