# EBAY | Single Item | Store | Store Categories (`crawlerbros/ebay-item-store-scraper`) Actor

Extract detailed product data from eBay individual item pages, seller store fronts, and store category pages. Get rich data including item specifics, all images, seller details, shipping/return terms, and more.

- **URL**: https://apify.com/crawlerbros/ebay-item-store-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Other, Developer tools
- **Stats:** 1 total users, 0 monthly users, 50.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are 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

## eBay Product Details Scraper — Single Item, Store & Store Categories

Extract detailed product data from eBay individual item pages, seller store fronts, and store category pages. Get comprehensive product information including item specifics, all high-resolution images, seller details, shipping terms, return policies, and more.

### What does this scraper do?

This actor extracts **rich, detailed product data** from three types of eBay pages:

- **Individual item pages** (`/itm/` URLs) — full product details with 22 data fields
- **Seller store pages** (`/str/` URLs) — discovers and scrapes all products from a seller's store
- **Store category pages** — scrapes products from specific categories within a seller's store

Unlike search result scrapers that only extract card-level data, this actor visits each product page to collect complete item specifics, all images, seller ratings, shipping/return terms, stock levels, and sales data.

> **Note**: Some fields may be empty for certain listings: `originalPrice` (only when discounted), `soldCount`/`watchCount`/`availableQuantity` (not shown on all listings), `bids` (only for auctions), and `sellerFeedbackPercent` (new sellers with zero feedback).

### Features

- Extract 22 detailed data fields per product
- Full item specifics extraction (Brand, Model, Processor, RAM, etc.)
- All high-resolution product images (up to 1600px)
- Seller details with feedback score and positive rating percentage
- Shipping cost, return policy, and item location
- Stock availability and units sold count
- Works with Buy It Now and Auction listings
- Automatic pagination for store pages
- Lightweight HTTP-based extraction for item pages (low compute cost)
- No login or cookies required

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `startUrls` | Array | Yes | — | eBay item, store, or store category URLs |
| `maxItems` | Integer | No | 50 | Maximum number of items to scrape |
| `proxy` | Object | No | No proxy | Proxy configuration. Works without proxy by default. Enable residential proxy if you experience blocks. |

#### Supported URL Formats

- **Single item**: `https://www.ebay.com/itm/267153498498`
- **Single item (with title)**: `https://www.ebay.com/itm/Product-Title-Here/267153498498`
- **Seller store**: `https://www.ebay.com/str/thriftbooks`
- **Store category**: `https://www.ebay.com/str/thriftbooks/Fiction/_i.html?_sacat=261186`

#### Example Input

```json
{
    "startUrls": [
        { "url": "https://www.ebay.com/itm/267153498498" }
    ],
    "maxItems": 10
}
````

#### Scraping a Seller Store

```json
{
    "startUrls": [
        { "url": "https://www.ebay.com/str/thriftbooks" }
    ],
    "maxItems": 50
}
```

### Output

Each scraped product contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `url` | String | Direct URL to the item listing |
| `id` | String | eBay item ID |
| `title` | String | Full product title |
| `price` | String | Current price with currency (e.g., "US $384.92") |
| `originalPrice` | String | Original price if item is discounted |
| `condition` | String | Item condition (New, Used, Refurbished, etc.) |
| `seller` | String | Seller name |
| `sellerFeedbackScore` | String | Seller total feedback count |
| `sellerFeedbackPercent` | String | Seller positive feedback percentage (empty for new sellers with no feedback) |
| `sellerUrl` | String | URL to seller's eBay store |
| `availableQuantity` | String | Number of items in stock |
| `soldCount` | String | Number of units sold |
| `watchCount` | String | Number of people watching this item |
| `location` | String | Item geographic location |
| `shippingCost` | String | Shipping cost or "Free shipping" |
| `returnPolicy` | String | Return policy terms |
| `images` | Array | All high-resolution product image URLs |
| `itemSpecifics` | Object | Key-value pairs of item specifics (Brand, Model, etc.) |
| `categories` | Array | Breadcrumb category path |
| `listingType` | String | "Buy It Now" or "Auction" |
| `bids` | String | Number of bids (for auction listings) |
| `scrapedAt` | String | ISO timestamp when the item was scraped |

#### Example Output

```json
{
    "url": "https://www.ebay.com/itm/267153498498",
    "id": "267153498498",
    "title": "HP Pro X360 435 G10 Laptop Touch 13.3\" AMD Ryzen 7 PRO 16GB 512GB SSD Win 11 Pro",
    "price": "US $384.92",
    "originalPrice": "",
    "condition": "Refurbished",
    "seller": "Discount Computer Depot",
    "sellerFeedbackScore": "156714",
    "sellerFeedbackPercent": "99.3%",
    "sellerUrl": "https://www.ebay.com/str/discountcomputerdepot",
    "availableQuantity": "10",
    "soldCount": "5",
    "watchCount": "12",
    "location": "Jacksonville, TX, United States",
    "shippingCost": "Free shipping",
    "returnPolicy": "30 days returns",
    "images": [
        "https://i.ebayimg.com/images/g/example1/s-l1600.jpg",
        "https://i.ebayimg.com/images/g/example2/s-l1600.jpg"
    ],
    "itemSpecifics": {
        "Brand": "HP",
        "Model": "HP Pro X360 435 G10",
        "Processor": "AMD Ryzen 7 PRO 7730U",
        "RAM Size": "16 GB",
        "SSD Capacity": "512 GB",
        "Screen Size": "13.3 in",
        "Operating System": "Windows 11 Pro",
        "Type": "Notebook/Laptop"
    },
    "categories": ["eBay", "Electronics", "Computers/Tablets & Networking", "Laptops & Netbooks"],
    "listingType": "Buy It Now",
    "bids": "",
    "scrapedAt": "2026-04-07T12:00:00.000000+00:00"
}
```

### Use Cases

- **Market Research**: Analyze product pricing, conditions, and availability across sellers
- **Price Monitoring**: Track price changes on specific eBay listings over time
- **Competitor Analysis**: Scrape competitor store inventories with full product details
- **Product Catalog Building**: Extract complete product specifications for catalog databases
- **Seller Intelligence**: Collect seller ratings, feedback scores, and store inventory data
- **Supply Chain Research**: Monitor product availability and shipping terms from suppliers

### How much does it cost to scrape eBay?

This scraper uses lightweight HTTP requests for individual item pages, keeping compute costs minimal. Store pages use a browser for initial product discovery, then HTTP for detail extraction.

| Scenario | Estimated Cost |
|----------|----------------|
| 10 individual items | ~$0.01 |
| 50 items from a store | ~$0.05 |
| 200 items from a store | ~$0.15 |

Costs depend on proxy usage and the number of pages scraped.

### Tips for Best Results

1. **Start with individual item URLs** for the lowest cost and fastest results
2. **Use store URLs** when you need to scrape an entire seller's inventory
3. **Set maxItems** to control costs when scraping large stores
4. **Works without proxy** by default. Enable residential proxies only if you experience access blocks

### FAQ

#### Can I scrape eBay search results with this actor?

This actor is designed for individual item pages and seller stores. For scraping eBay search results, use the companion [eBay Items Scraper](https://apify.com/) which is optimized for search result pages and category listings.

#### Does this actor support international eBay sites?

Yes, the scraper works with eBay domains worldwide including ebay.com, ebay.co.uk, ebay.de, ebay.fr, ebay.com.au, and others.

#### How many items can I scrape per run?

There is no hard limit. Use the `maxItems` parameter to control the number of items scraped per run. For large stores with thousands of products, consider splitting into multiple runs.

#### Does this actor need cookies or login?

No. The scraper works with publicly available eBay pages and does not require any authentication.

#### What happens if an item is no longer available?

The scraper handles ended and unavailable listings gracefully. It will extract whatever data is still visible on the page.

#### How is this different from eBay search scrapers?

Search scrapers extract basic card-level data (title, price, thumbnail) from search result pages. This actor visits each individual product page to extract 22 fields including full item specifics, all images, seller details, shipping/return terms, and sales data.

# Actor input Schema

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

List of eBay URLs to scrape. Supports individual item pages (/itm/), seller store pages (/str/), and store category pages.

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

Maximum number of items to scrape. Applies mainly to store/category pages.

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

Proxy configuration. Works without proxy by default. Enable residential proxy if you experience blocks.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ebay.com/itm/267153498498"
    }
  ],
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing detailed eBay product listings.

# 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": [
        {
            "url": "https://www.ebay.com/itm/267153498498"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ebay-item-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 = { "startUrls": [{ "url": "https://www.ebay.com/itm/267153498498" }] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ebay-item-store-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 '{
  "startUrls": [
    {
      "url": "https://www.ebay.com/itm/267153498498"
    }
  ]
}' |
apify call crawlerbros/ebay-item-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/ebay-item-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EBAY | Single Item | Store | Store Categories",
        "description": "Extract detailed product data from eBay individual item pages, seller store fronts, and store category pages. Get rich data including item specifics, all images, seller details, shipping/return terms, and more.",
        "version": "0.1",
        "x-build-id": "wSLnTskFFehmjvaPJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ebay-item-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ebay-item-store-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/crawlerbros~ebay-item-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ebay-item-store-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/crawlerbros~ebay-item-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ebay-item-store-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of eBay URLs to scrape. Supports individual item pages (/itm/), seller store pages (/str/), and store category pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of items to scrape. Applies mainly to store/category pages.",
                        "default": 50
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy configuration. Works without proxy by default. Enable residential proxy if you experience blocks.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
