# Ebay Product Scraper (`solid-scraper/ebay-product-scraper`) Actor

🛒 Effortlessly scrape eBay listings with this powerful eBay Product Scraper! Extract titles, prices, images & more for research, pricing, and lead gen. ⚡ Fast, efficient, and SEO-ready—boost your eCommerce workflow instantly.

- **URL**: https://apify.com/solid-scraper/ebay-product-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### eBay Product Scraper 🔍

**eBay Product Scraper** is an Apify actor that takes a list of eBay product URLs and automatically extracts product details, seller information, pricing, images, shipping, and the item description. If you’re looking for an **eBay product scraper**, **eBay listing scraper**, or **scrape eBay product data** for research and analysis, this tool helps you do it at scale—saving you hours of manual work.

Whether you’re a marketer, data analyst, researcher, or an operations team building an eBay inventory dataset, this actor turns item pages into structured JSON you can immediately use in your workflows.

***

### Why choose eBay Product Scraper?

| Feature | Benefit |
|---|---|
| ✅ All-in-one extraction | Pulls product title, images, price, condition, shipping, delivery, returns, and description in one run |
| ✅ Reliability-focused fetching | Includes resilient fetching with fallbacks to handle cases where content can’t be retrieved |
| ✅ Structured, consistent output | Returns uniform fields per URL (including success status and error details when applicable) |
| ✅ Dataset-ready results | Pushes results to Apify datasets automatically for easy export and downstream use |
| ✅ Built for batch scraping | Processes multiple product URLs in a single actor run with practical pacing |
| ✅ Automation-friendly integration | Works cleanly in automation pipelines where you consume JSON results programmatically |

***

### Key features

- 📌 **URL-based product scraping**: Scrapes from the eBay product URLs you provide via the `Urls` input list.
- 🧾 **Complete item details**: Extracts `product_title`, `product_price`, `product_condition`, `shipping_info`, `delivery_info`, `return_policy`, and `item_specifics`.
- 🖼️ **Image URL collection**: Collects product images into the `product_image` array (with higher-resolution URLs when available).
- 🏷️ **Seller insights**: Captures `seller_name`, `seller_items_sold`, and `positive_feedback` from the seller card.
- 📄 **Readable and HTML description**: Provides both `item_description` (plain text) and `item_description_html` (main body HTML or full HTML).
- 💾 **Structured JSON dataset output**: Saves one JSON object per URL, including `detail_url`, so it’s easy to track provenance.
- 🛡️ **Resilience and failure reporting**: When a scrape fails, the actor still returns a result object with `success: False` and an `error` message.
- 🔄 **Batch processing with pacing**: Adds a short delay between requests to keep runs stable across multiple items.

***

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "Urls": [
    "https://www.ebay.com/itm/357269512786"
  ]
}
```

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `Urls` | ✅ | A list (array) of eBay product URLs to scrape. The actor will process each URL and output structured product + seller details. |

***

### Output

The actor saves each product’s data in JSON format (one result object per provided URL).

Example output (sample):

```json
[
  {
    "success": true,
    "seller_name": "Example Seller",
    "seller_items_sold": "1234",
    "positive_feedback": "99.2% positive",
    "product_title": "Example Product Title",
    "product_image": [
      "https://example.com/image1.jpg",
      "https://example.com/image2.jpg"
    ],
    "product_price": "$19.99",
    "product_condition": "New",
    "shipping_info": "Ships from ...",
    "delivery_info": "Estimated delivery ...",
    "return_policy": "Return policy details ...",
    "item_number": "357269512786",
    "item_description": "Plain text description ...",
    "item_description_html": "<div>...</div>",
    "item_specifics": {
      "Brand": "Example Brand",
      "Model": "Example Model"
    },
    "detail_url": "https://www.ebay.com/itm/357269512786"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `success` | boolean | Indicates whether the scrape for that URL succeeded. |
| `seller_name` | string | The seller name extracted from the item page. |
| `seller_items_sold` | string | Seller feedback/items-sold indicator extracted from the seller card. |
| `positive_feedback` | string | Positive feedback percentage/label extracted from the seller card. |
| `product_title` | string | The product title (cleaned if it contains “Details about”). |
| `product_image` | array | List of product image URLs collected from the item page. |
| `product_price` | string | The extracted price shown on the item page. |
| `product_condition` | string | The extracted condition value for the product. |
| `shipping_info` | string | Shipping text extracted from the shipping section. |
| `delivery_info` | string | Delivery-related text extracted from the delivery section. |
| `return_policy` | string | Return policy text extracted from the returns section. |
| `item_number` | string | Item number extracted from the URL (when available). |
| `item_description` | string | Plain-text item description extracted from the description content. |
| `item_description_html` | string | HTML content for the item description (main body inner HTML when available). |
| `item_specifics` | object | Key-value pairs for item specifics extracted from the item page. |
| `detail_url` | string | The original item URL (provenance for every record). |
| `error` | string | Present when `success` is `False`; contains an error message for the URL. |

You can export the resulting dataset from Apify in common formats like JSON (and typically CSV depending on your workflow).

***

### How to use eBay Product Scraper (via Apify Console)

1. **Open Apify Console** 🔐\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** tab.

2. **Find the actor**\
   Search for **eBay Product Scraper** and open the actor page.

3. **Go to the Input section**\
   Paste input JSON and make sure it matches the schema with `Urls`.

4. **Enter your product URLs**\
   Add one or more eBay product links inside the `Urls` array. Each URL becomes one output record.

5. **Run the actor** ▶️\
   Click **Run**. During the run, you’ll see log messages like processing progress and whether each URL succeeded or failed.

6. **Watch the dataset build**\
   The actor pushes results to the dataset as a batch at the end of processing (`charged_event_name="result"` in the code).

7. **Open results in the Dataset tab** 📊\
   After completion, open the dataset to preview records and export the data for your CRM, spreadsheets, or analysis pipeline.

No coding required—get accurate results in minutes with **eBay Product Scraper**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for eBay product scraping workflows**: Designed to excel at extracting eBay item details for research, competitor price monitoring, and automated data enrichment.
- 🌐 **Built for eBay listing scraper use cases**: Outputs both structured fields and rich description content so you can power downstream analysis without revisiting pages.
- 🛡️ **Resilient fetching behavior**: Uses practical fallbacks and returns clear failure objects (`success: False` + `error`) so your pipeline can handle partial runs.
- 🔄 **Clean, repeatable output schema**: Every scraped URL produces a consistent JSON shape—ideal for “scrape eBay product data” at scale.
- 📦 **Description in two forms**: `item_description` (plain text) and `item_description_html` (HTML body), supporting both marketing-style reading and data processing.

***

### Best use cases

- 📈 **Ecommerce analysts building item detail datasets**: Collect titles, prices, conditions, and item specifics into a structured dataset for analysis.
- 🛒 **Market research teams monitoring competitors**: Automate “scrape eBay product data” runs and compare product and seller signals over time.
- 🧮 **Inventory and catalog enrichment**: Use automated eBay product scraping to enrich internal catalogs with images, shipping, and return policy details.
- 🚀 **Pricing and listing intelligence**: Track `product_price` and condition fields to understand listing patterns and product availability.
- 🧾 **Data engineering pipelines (API-ready JSON)**: Integrate the actor’s JSON output into ETL jobs, databases, and reporting dashboards.
- 🎯 **Content and listing research**: Extract full item descriptions and HTML (`item_description_html`) for qualitative evaluation and taxonomy building.
- 🏷️ **Brand/keyword-driven exploration**: Use your own eBay product URLs to quickly build an eBay listing scraper dataset without manual page-by-page extraction.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `Urls` as an array of eBay product URL strings

- **Proxy Support**
  - ✅ Built-in support for using proxy URLs when provided internally by the actor run environment

- **Retry Mechanism**
  - ✅ Includes resilient fetching behavior and fallbacks (implementation details are handled internally)

- **Dataset Structure**
  - ✅ JSON array of result objects (one object per URL)

- **Rate Limits & Performance**
  - ⏳ Designed for batch runs with a short delay between processed URLs to keep runs stable

- **Limitations**
  - ❌ If a page can’t be fetched or parsed, the result will return `success: False` and an `error` message for that URL
  - ❌ Missing fields are possible when the corresponding section is not present in the scraped content

***

### FAQ

#### ✅ What can eBay Product Scraper extract from an eBay item page?

It extracts product and seller details including `product_title`, `product_price`, `product_condition`, `shipping_info`, `delivery_info`, `return_policy`, `item_specifics`, plus seller fields like `seller_name`, `seller_items_sold`, and `positive_feedback`. It also collects images into `product_image`, and provides both `item_description` (plain text) and `item_description_html`.

#### ❌ Do I need to provide search terms or keywords?

No. This actor works from direct eBay product URLs provided in the `Urls` input field. If you already know the items you want, you can run it directly.

#### 💾 Where do the results go after the run?

The actor pushes the collected results to an Apify dataset (`Actor.push_data` in the code). You can then export or preview the JSON records from the dataset page.

#### 💻 Can I use this actor in a Python or API pipeline?

Yes. The actor produces structured JSON you can consume programmatically. Each dataset record includes a `success` boolean, a `detail_url`, and the extracted product/seller fields, with an `error` message when scraping fails.

#### 🔁 What happens if a specific URL fails to scrape?

If fetching or parsing fails for a URL, the actor returns a result object with `success: False` and an `error` field. It still includes the related `url` information in the failure response so you can identify what needs rework.

#### 🌍 Does it support scraping multiple products in one run?

Yes. Provide multiple links in the `Urls` array—each URL is processed and results are collected into one JSON dataset output.

#### ⚖️ Is this tool legal and compliant to use?

The actor is intended to work with publicly accessible sources. You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), privacy requirements, spam regulations, and platform terms while using the extracted data.

***

### Support & feature requests

If you’re using **eBay Product Scraper** and want changes or improvements, we’d love to hear from you.

- 💡 **Feature Requests**: For example, enhancements like additional export-friendly formatting, more robust handling for missing fields, or expanding the set of item fields would be great ideas—share what you need.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this **eBay product scraper**.

***

*If you’re serious about eBay data scraping tool workflows, **eBay Product Scraper** gives you structured eBay item details without manual copy-paste.*

# Actor input Schema

## `Urls` (type: `array`):

List of eBay product URLs to scrape.

## Actor input object example

```json
{
  "Urls": [
    "https://www.ebay.com/itm/357269512786"
  ]
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/ebay-product-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 = { "Urls": ["https://www.ebay.com/itm/357269512786"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HbWB0Jw53pdBXWU9k/builds/BkoidQQUBaY0kCOH1/openapi.json