# eBay Product Details Scraper (`astravalabs/ebay-products-scraper`) Actor

Extract detailed product data from eBay item URLs across 13 marketplaces. Get prices, availability, seller data, shipping, returns, item specifics, variations, images, demand signals, and plain-text descriptions. No eBay account, API key, or proxy setup required.

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

## Pricing

from $2.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.

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 Products Scraper

Turn eBay item URLs into detailed, structured product records for price
monitoring, catalog enrichment, seller research, and marketplace analysis.

> **Unofficial tool:** This Actor is independently developed and is not
> affiliated with, endorsed by, or sponsored by eBay Inc. eBay names and
> trademarks belong to their respective owners.

Paste up to 1,000 eBay product URLs and get one analysis-ready dataset row per
successfully scraped listing. Each record can include prices, availability,
auction data, seller reputation, shipping, returns, item specifics, variations,
images, demand signals, promotions, and the seller's plain-text description.

No eBay account, API key, or proxy configuration is required.

### Need to discover product URLs?

Use the [eBay Listings Scraper](https://apify.com/astravalabs/ebay-listings-scraper)
to search eBay by keyword, marketplace, condition, price, buying format, and
sort order. Pass the `url` values from its dataset to this Actor's
`productUrls` input for complete item-page enrichment.

### Why use this Actor?

- **Get complete item-page data.** The output schema covers 119 fields across
  product identity, offers, sellers, fulfillment, demand, media, and listing
  lifecycle.
- **Monitor both active and ended items.** Records distinguish active listings
  from ended or unavailable listings and retain exact start and end timestamps
  when eBay exposes them.
- **Work across 13 eBay marketplaces.** Mix URLs from supported country sites
  in one run and let the Actor infer the marketplace from each URL.
- **Keep values ready for analysis.** Prices, counts, dates, booleans, and
  identifiers are normalized while the original localized text remains
  available where its exact meaning matters.
- **Capture product variations and descriptions.** Collect option dimensions,
  selected values, availability, and safely reduced plain-text descriptions.
- **Build repeatable workflows.** Run from Apify Console or the API, schedule
  recurring collections, export in common formats, and inspect a detailed run
  report when an item cannot be collected.

### Who is it for?

- **Pricing and e-commerce teams** tracking item-level price, discount,
  shipping, stock, and promotion changes.
- **Sellers and resellers** researching competing offers, seller quality,
  demand signals, and listing formats.
- **Catalog and marketplace teams** enriching SKUs with eBay identifiers,
  item specifics, images, variations, and category paths.
- **Brands and analysts** comparing product presentation and seller activity
  across localized eBay sites.
- **Developers and data teams** building scheduled datasets, alerts,
  dashboards, and product intelligence pipelines.

### Common use cases

#### Price and availability monitoring

Schedule the same product URLs and compare `displayedPrice`, `originalPrice`,
`discountPercentage`, `quantityAvailable`, `listingStatus`, shipping, coupons,
and VAT presentation between runs.

#### Seller and offer intelligence

Analyze seller feedback, badges, detailed seller ratings, item location,
shipping options, return policy, Best Offer availability, and auction bids in
one record.

#### Catalog enrichment

Join eBay item IDs, ePIDs, brand, model, MPN, GTIN, UPC, EAN, ISBN, category
paths, item specifics, full-size images, and product variations to an existing
catalog.

#### Cross-marketplace comparison

Submit URLs from different supported country sites in the same run. Every row
identifies its marketplace and preserves the localized price, currency,
shipping, delivery, and policy presentation.

#### Listing lifecycle and demand tracking

Use listing start/end dates, status, quantities sold, watchers, recent views,
cart count, offer count, bids, and scarcity text to follow public listing
activity over time.

### Quick start

Paste this input into Apify Console:

```json
{
  "productUrls": [
    "https://www.ebay.com/itm/188489329976"
  ],
  "marketplace": "AUTO",
  "includeDescription": true,
  "includeVariations": true
}
```

The Actor saves successful products to the default dataset. Open the **Output**
or **Dataset** tab to view them, download JSON, CSV, Excel, XML, or RSS, or
retrieve the results with the Apify API.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `productUrls` | string array | example URL | One to 1,000 eBay item-page URLs. This is the simplest input for Console and API users. |
| `products` | object array | none | Advanced entries containing `url`, optional `variantId`, and optional search-page `referrer`. |
| `marketplace` | string | `AUTO` | Infer the marketplace from every URL, or require all input URLs to belong to one selected marketplace. |
| `includeDescription` | boolean | `true` | Include the seller-visible plain-text description. This can require one additional eBay request per product. |
| `includeVariations` | boolean | `true` | Include variation dimensions, selected values, and option availability when displayed. |

Provide at least one item through `productUrls` or `products`. You can combine
the two fields, up to 1,000 unique products in total. Duplicate normalized
product URLs are removed automatically.

#### Advanced structured input

Use `products` when another Actor or your own discovery process already knows
the selected variation or the eBay search page that led to the item:

```json
{
  "products": [
    {
      "url": "https://www.ebay.com/itm/123456789012",
      "variantId": "987654321098",
      "referrer": "https://www.ebay.com/sch/i.html?_nkw=example"
    }
  ],
  "marketplace": "AUTO",
  "includeDescription": true,
  "includeVariations": true
}
```

`variantId` must be numeric. A variation ID in the URL's `var` query parameter
is also preserved. Tracking parameters are removed before collection.

### Supported marketplaces

| Input | eBay site | Market | Currency |
| --- | --- | --- | --- |
| `US` | ebay.com | United States | USD |
| `UK` | ebay.co.uk | United Kingdom | GBP |
| `DE` | ebay.de | Germany | EUR |
| `AU` | ebay.com.au | Australia | AUD |
| `CA` | ebay.ca | Canada | CAD |
| `FR` | ebay.fr | France | EUR |
| `IT` | ebay.it | Italy | EUR |
| `ES` | ebay.es | Spain | EUR |
| `NL` | ebay.nl | Netherlands | EUR |
| `IE` | ebay.ie | Ireland | EUR |
| `AT` | ebay.at | Austria | EUR |
| `CH` | ebay.ch | Switzerland | CHF |
| `PL` | ebay.pl | Poland | PLN |

With `marketplace: "AUTO"`, each URL is assigned independently, so a single
run can contain several marketplaces. Selecting a specific code validates that
every product URL and referrer belongs to that marketplace.

### Output

Every successfully validated product produces one dataset item. The example
below is shortened; optional fields are `null` or empty when eBay does not
display a reliable value.

```json
{
  "marketplace": "US",
  "itemId": "123456789012",
  "variantId": null,
  "title": "Example product",
  "url": "https://www.ebay.com/itm/123456789012",
  "canonicalUrl": "https://www.ebay.com/itm/123456789012",
  "categoryId": "9355",
  "categoryPath": ["Electronics", "Cell Phones & Smartphones"],
  "listingStatus": "ACTIVE",
  "listingType": "FIXED_PRICE",
  "condition": "Pre-Owned",
  "displayedPriceText": "$249.99",
  "displayedPrice": 249.99,
  "currency": "USD",
  "originalPrice": 299.99,
  "discountPercentage": 16.67,
  "bestOfferAvailable": true,
  "quantitySold": 42,
  "watchCount": 18,
  "brand": "Example Brand",
  "model": "Example Model",
  "itemSpecifics": {
    "Storage Capacity": "128 GB",
    "Color": "Black"
  },
  "sellerUsername": "example-seller",
  "sellerFeedbackScore": 12540,
  "sellerFeedbackPercentage": 99.8,
  "topRatedSeller": true,
  "shippingPrice": 0,
  "shippingCurrency": "USD",
  "freeShipping": true,
  "returnsAccepted": true,
  "returnWindowDays": 30,
  "imageUrls": [
    "https://i.ebayimg.com/images/g/example/s-l1600.jpg"
  ],
  "variations": [],
  "descriptionText": "Seller-provided listing description...",
  "collectedAt": "2026-07-31T12:00:00+00:00"
}
```

#### Data groups

| Group | Examples |
| --- | --- |
| Identity and catalog | Item ID, variation ID, title, subtitle, category ID/path, ePID, brand, model, MPN, GTIN, UPC, EAN, ISBN, item specifics |
| Price and promotions | Displayed/original/unit/range/converted prices, discount, coupon, financing, VAT, import charges |
| Lifecycle and demand | Active/ended status, start/end dates, listing type, availability, quantity, sold count, watchers, recent views, carts, offers, bids, scarcity |
| Seller | Username, profile URL, seller type, feedback score/percentage, detailed ratings, badges, top-rated status, response and join text |
| Fulfillment and returns | Item location, shipping cost/type/options, destinations, exclusions, handling, delivery estimate, pickup, return window and responsibility |
| Product trust and media | Condition note, product ratings/reviews, listing badges, authenticity, private listing, video, full-size image gallery |
| Variations and content | Variation dimensions and option availability, validated description URL, plain-text seller description |

The complete field contract, types, nullability, and descriptions are available
in the Actor's output schema.

#### CSV-friendly item specifics

`itemSpecifics` is a native JSON object whose keys differ by category. The
equivalent `itemSpecificsList` repeats those attributes as ordered
`{"name", "value"}` objects so dynamic specifications are retained in CSV and
spreadsheet exports.

### Run reports and failures

The product dataset contains only validated product records, keeping its schema
consistent. Missing, blocked, or unrecognized pages are reported separately in
the run's `RUN_REPORT` key-value-store record.

The report includes:

- requested, parsed, saved, recovered, and failed product counts;
- per-product attempts and outcome classifications;
- response and optional-description request metrics;
- runtime, concurrency, dataset-write, and cost-estimate diagnostics.

HTTP 404 and 410 responses are treated as missing items and are not retried.
Transient network or access failures receive a bounded retry with a fresh
session. If no input can be validated as a genuine eBay item page, the run
fails clearly instead of returning misleading rows.

### Pricing

The price is **$2.99 per 1,000 successfully saved products** ($0.00299 per
product). This includes the platform compute, data transfer, and proxy usage
required by the Actor run. You do not need to provide or configure your own
proxies, and enabling descriptions does not add a separate request or proxy
charge.

Failed or missing products do not create dataset rows and are not charged as
product results. You can use Apify's maximum-cost-per-run setting when you need
a strict budget cap.

| Successful products | Result charge |
| ---: | ---: |
| 10 | $0.03 |
| 100 | $0.30 |
| 1,000 | $2.99 |

### API

Replace `<username>` and `<APIFY_TOKEN>` in these examples with the Actor
owner and your Apify API token.

#### Run and wait for dataset items

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<username>~ebay-products-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": [
      "https://www.ebay.com/itm/188489329976"
    ],
    "marketplace": "AUTO",
    "includeDescription": true,
    "includeVariations": true
  }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("<username>/ebay-products-scraper").call(run_input={
    "productUrls": [
        "https://www.ebay.com/itm/188489329976",
    ],
    "marketplace": "AUTO",
    "includeDescription": True,
    "includeVariations": True,
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["itemId"], product["displayedPrice"], product["currency"])
```

### Important data semantics

- `displayedPrice` is the marketplace presentation seen during collection.
  `convertedPrice` is populated only when eBay separately displays a different
  converted offer value.
- Shipping, delivery, import-charge, and VAT fields reflect the localized page
  and current destination context. They are not universal seller policy.
- Localized fields such as `shippingText`, `returnsText`, `couponText`, and
  `vatText` preserve eBay's wording. Normalized companion fields are populated
  only when the meaning is unambiguous.
- The Actor does not download product images. It returns ordered, deduplicated
  links to the full-size images displayed by eBay.
- Seller description HTML is treated as untrusted and is not returned. Only
  reduced plain text is included when `includeDescription` is enabled.
- The Actor collects public item pages only. It does not log in, access private
  account data, solve CAPTCHAs, or bypass explicit access denial.

### Responsible use

This Actor collects publicly available information. You are responsible for
ensuring that your use of the data complies with eBay's terms, applicable laws,
privacy rules, intellectual-property rights, and any contractual obligations.

# Actor input Schema

## `productUrls` (type: `array`):

One to one thousand eBay item-page URLs. The marketplace is inferred from each URL by default.

## `products` (type: `array`):

Advanced JSON input for listings-scraper enrichment. Each entry accepts a URL, optional variation ID, and optional originating search-page referrer.

## `marketplace` (type: `string`):

Infer the localized marketplace from each URL, or require every URL to use one selected marketplace.

## `includeDescription` (type: `boolean`):

Return the listing description. This may require one additional validated eBay request.

## `includeVariations` (type: `boolean`):

Return variation dimensions, selected values, and availability when displayed.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.ebay.com/itm/188489329976"
  ],
  "marketplace": "AUTO",
  "includeDescription": true,
  "includeVariations": true
}
```

# Actor output Schema

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

No description

## `runReport` (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 = {
    "productUrls": [
        "https://www.ebay.com/itm/188489329976"
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,astravalabs/ebay-products-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/OQ3LBp9HwibGdoFTF/builds/zLU5gDVXbh5soVysM/openapi.json