eBay Product Scraper - Prices, Auctions & Buy It Now

Use this eBay product scraper to extract active listings across 13 country markets, including prices, shipping, seller data, auction bids, Buy It Now listings, images, item IDs, and diagnostics.

Access status - October 25, 2026: owner cloud checks using residential and direct connections recovered no priced listings. eBay and the priced fallback returned HTTP 403; an earlier direct run returned only a price-less discovery row. Do not use these checks as evidence of a working price feed. Verify one qualified result on your own authorized access path before scheduling or scaling. Diagnostics have no product or dataset-item fee; startup charges still apply.

Scheduled billing change: from November 8, 2026 at 17:56 Europe/Amsterdam (16:56 UTC), customers pay Apify platform usage in addition to the existing event fees. All event prices stay the same. Until then, platform usage remains included in event pricing. After the change, platform usage and startup charges can apply even when a run is blocked or returns no listings.

Best first run

{
  "searchQuery": "sony wh-1000xm5",
  "ebayDomain": "ebay.com",
  "maxProducts": 1,
  "requirePrice": true,
  "fetchDetails": false,
  "enableAiAnalysis": false
}

Use this actor when you need an eBay product scraper, active listing monitor, auction intelligence feed, price-band dataset, or cross-market e-commerce monitor and you can tolerate eBay's current anti-bot variability. Start with an active keyword run; treat direct item URLs and soldOnly: true as advanced proxy-dependent JSON modes until your path proves it can reach item or completed-sale pages.

Related commerce workflows: use Amazon Scraper for ASIN and Best Sellers Rank tracking.

No cookies, no OAuth, no API keys (for the scraping) - runs on public data only. Hosted AI providers require your own API key when enabled; self-hosted Ollama needs no key. Provider token charges are separate from Actor report events.

Scrape eBay product listings with prices, shipping, seller ratings, condition, and bid counts across all 13 eBay country domains. If active search pages are blocked, the actor attempts fallback listing recovery with a reduced but billable active-listing field set. Direct item URLs and sold-listings intelligence are advanced proxy-path-dependent JSON modes. Auction + Buy It Now + optional AI market analysis.

eBay Product Scraper

Search eBay by keyword to extract item IDs, titles, prices, shipping, seller names, feedback scores, condition, bids, time left, listing type, sold count, image URL, location, currency, and marketplace domain. Use it for resale research, competitor monitoring, auction tracking, marketplace pricing, and cross-border e-commerce analysis.

Sold Listings Mode Status

soldOnly: true is an advanced JSON-only mode, hidden from the standard Console form because eBay blocks completed-sale pages on many Apify-hosted paths. Only enable it after a tiny test proves your own proxy path can reach those pages. Blocked sold-listings runs emit diagnostics and do not charge listing or summary events. Active-listing access does not prove sold-listing access.

What It Does

eBay Scraper extracts structured product data from all 13 eBay country domains - US, UK, Germany, France, Italy, Spain, Australia, Canada, Netherlands, Austria, Switzerland, Ireland, and Poland. Provide a keyword and the actor returns 25+ fields per result: title, price, currency, shipping, condition, seller, feedback score, bid count, time left, listing type, sold count, and image URL. Advanced JSON inputs also exist for direct listing URLs and sold-listings tests when your proxy path supports them.

Operating modes:

1. Active-listings mode (default) - attempts to extract active auction and Buy It Now listings matching your keyword. Returns up to 100 results per run. Primary eBay search supports sort order, price range, condition, and listing-type filters. Charges $0.003 per qualifying priced listing.

Fallback indexes do not verify item condition or preserve eBay sort order. They are used only with itemCondition: "any" and sortBy: "best_match". When a filtered primary search fails, the actor stops with a diagnostic instead of returning broader, differently ordered results. It never silently removes your filters. Fallback rows carry source: "picclick_fallback" or source: "search_index_fallback"; indexed prices are not a guarantee that the listing remains available or that its current checkout price matches. scraped_at records retrieval time, not the index's last update.

Fallback price-range filters require an explicit price in the selected marketplace's currency. Different or unverified currencies are excluded; the actor does not perform exchange-rate conversion.

If eBay and the full-listing fallback both challenge a live search, the actor can return clearly marked data_completeness: "discovery_only" rows from a public search index. Those recovery rows contain the verified eBay item ID, canonical URL, title, and indexed description snippet; price, shipping, seller, and auction fields remain empty rather than being guessed.

Discovery-only and partial rows do not incur the $0.003 product-scraped event; Apify's standard $0.00001 default-dataset item event may still apply.

For price workflows, set requirePrice: true. This excludes incomplete and discovery-only listings from the default dataset and skips the price-less search-index fallback. It requires a valid item identity, title, positive price with matching currency evidence, and a supported listing type. It does not verify that an indexed listing remains available. Missing results are not zero prices, sales, removals, or price changes.

2. Advanced direct item URL mode (productUrls, JSON input only) - accepts known /itm/ URLs and tries the primary eBay item page first, then fallback item recovery when eBay blocks the page. This mode is proxy-path dependent. Charges $0.003 only when a listing is recovered.

3. Advanced sold-listings mode (soldOnly=true, JSON input only) - switches to eBay's completed-sale filter (LH_Sold=1&LH_Complete=1, ~90-day window). This mode is currently proxy-path dependent and may return diagnostics when eBay blocks completed-sale pages. Sold-listing and summary event fees apply only when qualifying sold rows or summaries are emitted.

AI analysis (enableAiAnalysis=true) - sends scraped listings to OpenRouter, Anthropic Claude, Google Gemini, OpenAI GPT, or self-hosted Ollama for a market overview, price-bracket analysis, seller-landscape summary, and buying recommendations. Charges $0.05 per analysis.

By default, runs try HTTP extraction with browser recovery, polite 1-2.5 second delays, and cross-page deduplication. HTTP-only execution is optional. Current eBay HTTP 403 blocks trigger active-listing fallback where permitted by the input filters, then diagnostics if no usable listing data can be recovered.

Supported eBay Domains:

Domain	Country	Currency
ebay.com	United States	USD
ebay.co.uk	United Kingdom	GBP
ebay.de	Germany	EUR
ebay.fr	France	EUR
ebay.it	Italy	EUR
ebay.es	Spain	EUR
ebay.com.au	Australia	AUD
ebay.ca	Canada	CAD
ebay.nl	Netherlands	EUR
ebay.at	Austria	EUR
ebay.ch	Switzerland	CHF
ebay.ie	Ireland	EUR
ebay.pl	Poland	PLN

Features

• Active listing fallback recovery - active keyword runs try a fallback listing index when eBay returns HTTP 403
• Advanced sold-listings mode (JSON-only watchlist) - completed-sale records and summaries when your proxy path can reach eBay completed-sale pages
• 13 eBay country domains - US, UK, DE, FR, IT, ES, AU, CA, NL, AT, CH, IE, PL with automatic currency resolution
• Auction + Buy It Now - both listing types in a single run, filter by either or scrape all
• 25+ fields per listing - title, price, currency, MSRP/list_price, shipping, condition, seller, feedback score, bids, time-left, sold count, sold date, sponsored flag, best-offer flag, images, location
• Detail-page enrichment (fetchDetails=true) - seller information, full item specifics, and complete description from individual listing pages
• Flexible filtering - price range, item condition (new/used/refurbished/open box), listing type, sort order
• 5 AI providers - OpenRouter (recommended, 300+ models), Anthropic Claude, Google Gemini, OpenAI GPT, Ollama (self-hosted)
• Pay-per-event pricing - qualified listing and completed-analysis events, plus startup and default-dataset item fees; platform usage is billed separately from November 8, 2026 at 17:56 Europe/Amsterdam
• Cross-page deduplication - maxProducts counts unique listings, not raw slots

Use Cases

• Resellers & Arbitrage - monitor active prices, auction bids, and Buy It Now offers across multiple eBay domains.
• Price Monitoring & Alerts - schedule daily active-listing runs to track asking-price changes for specific SKUs across marketplaces.
• Market Research - analyze pricing distribution, seller landscape, and demand signals (bids, sold counts) for any product category. AI analysis adds structured price-bracket breakdowns and buying recommendations.
• Competitive Intelligence - monitor competitor pricing and seller strategies across multiple regions. Track how prices differ between ebay.com, ebay.co.uk, and ebay.de for the same product.
• Auction Intelligence - filter to auctions only, sort by ending soonest, and track bid counts and time-left for active listings. Identify underpriced auctions before they close.
• E-commerce Sourcing - search for wholesale or bulk offers, then inspect seller and shipping data when available. The primary search supports Buy It Now and condition filters; there is no free-shipping input filter.
• Vintage & Collectibles Pricing - compare active asking prices and auction pressure; use sold-listings intelligence only after a small completed-sale test run succeeds on your proxy path.
• Academic & Policy Research - export structured datasets for price-index research, consumer behavior studies, or e-commerce market analysis.

Input

Search Parameters

• searchQuery - Keyword to search for on eBay (e.g., "laptop", "vintage Rolex", "pokemon cards"). Also accepts CLI aliases query, q, search, keyword, and searchTerm for compatibility with existing workflows.
• productUrls - Hidden from the standard Console form. Advanced JSON-only list of direct eBay listing URLs (e.g., https://www.ebay.com/itm/123456789). Direct item pages and fallback item lookups are proxy-path dependent; use searchQuery for production runs.
• ebayDomain - eBay country domain. Options: ebay.com (US, default), ebay.co.uk (UK), ebay.de (Germany), ebay.fr (France), ebay.it (Italy), ebay.es (Spain), ebay.com.au (Australia), ebay.ca (Canada), ebay.nl (Netherlands), ebay.at (Austria), ebay.ch (Switzerland), ebay.ie (Ireland), ebay.pl (Poland). Hidden API aliases domain and legacy ebaySite are also accepted.
• listingType - Filter by listing format: all (default), auction, or buy_it_now.
• sortBy - Sort results: best_match (default), price_low, price_high, ending_soonest, newly_listed.
• itemCondition - Filter by condition: any (default), new, open_box, refurbished, used.
• minPrice / maxPrice - Price range filter in the domain's local currency.
• maxProducts - Maximum number of results per run (1-100, default 25). Advanced soldOnly=true is capped at 50 for bill safety.
• fetchDetails - Visit each listing page for seller info, full description, and item specifics (slower, ~2-3x run time).

Execution And Result Quality

• useBrowser - Default true, preserving the existing recovery path and requiring at least 4096 MB. Set false for HTTP-only search and detail requests; no browser is launched. HTTP-only runs accept allocations from 512 MB. Smaller allocations also provide less CPU, so they may time out sooner and are not guaranteed to cost less overall. Proxy settings are respected in both modes; a failed configured proxy never silently switches to a direct connection.
• requirePrice - Default false for compatibility. Set true for qualified priced listings only. Excluded rows request neither product nor default-dataset item fees. If no row qualifies, inspect Diagnostics. A successful run status alone is not a successful price check.

Both inputs must be JSON booleans, not strings. Start with one result, details and AI disabled, and a short timeout. Keep browser mode at 4096 MB; a lower allocation is rejected with an input diagnostic. The default allocation remains 4096 MB. A smaller-memory run is not evidence of reliable access, complete data, or profitability.

Advanced Sold-Listings Intelligence

• soldOnly - Hidden from the standard Console form. Set true in JSON input only after a test proves completed-sale pages are reachable for your proxy path. Default: false.
• soldDateLookback - Window in days for velocity calculation (30-365, default 90). eBay retains ~90 days of sold data.

AI Analysis

• enableAiAnalysis - Enable AI market analysis. Default: false. Hosted providers require your own API key; self-hosted Ollama needs no key.
• llmProvider - AI backend: openrouter (default), anthropic, google, openai, or ollama.
• llmModel - Override the provider default model. Leave blank to use the recommended default.
• openrouterApiKey - OpenRouter API key (openrouter.ai/keys).
• anthropicApiKey - Anthropic API key (console.anthropic.com).
• googleApiKey - Google AI API key (aistudio.google.com/app/apikey).
• openaiApiKey - OpenAI API key (platform.openai.com/api-keys).
• ollamaBaseUrl - Ollama base URL (default: http://localhost:11434). No API key needed for self-hosted.

Proxy Settings

• proxyConfiguration - Apify Proxy settings. eBay currently blocks many Apify-hosted runs, including some residential exits. Active searches have fallback listing recovery, but sold-listings mode still needs eBay completed-sale pages to be reachable. If you bring a premium proxy, match its country to the selected eBay domain and validate with a tiny run before scaling.

Output

The default dataset contains buyer-facing listing, sold-summary, and optional AI-analysis records. Blocked or zero-result runs write diagnostic_item: true records only to the separate diagnostics dataset, available through the run's Diagnostics output link. Diagnostics have no product or dataset-item fee. The existing Actor startup fee still applies, as does separately billed platform usage from November 8, 2026 at 17:56 Europe/Amsterdam.

Listing Item Fields

Field	Description
itemId	eBay item ID (the numeric string from the /itm/ URL path)
title	Product listing title
url	Direct link to the eBay listing
price	Numeric asking price observed in the stated source; indexed prices may be stale
price_text	Price as displayed (e.g., "$29.99")
currency	ISO 4217 currency code (e.g., USD, GBP, EUR)
list_price	Strikethrough / MSRP numeric price if discounted, else null
list_price_text	Strikethrough price as displayed (e.g., "$299.99")
shipping_cost	Shipping cost as float (0.0 = free, null = unknown)
shipping_text	Shipping info as displayed
free_shipping	Bool - true when shipping_cost == 0
condition	Item condition (New, Used, Refurbished, Open Box, etc.)
seller	Combined seller string, e.g. "logitech 99.6% positive (20.7K)"
seller_username	Bare seller username
seller_feedback_percentage	Seller feedback percentage as float
seller_feedback_count	Feedback count as integer (parsed from "(20.7K)" -> 20700)
bids	Number of bids (auction items only)
end_time	Auction end date/time in ISO 8601 format (auction items only, else null)
time_left	Time remaining for auctions as human-readable text (e.g., "2d 4h")
sold_price	Final sale price for completed auction listings in soldOnly mode (else null)
listing_type	auction, buy_it_now, or buy_it_now_or_best_offer
best_offer	Bool - true when seller accepts offers
is_sponsored	Bool - true for promoted/sponsored listings
image_url	Product image URL
sold_info	Raw sold/watching badge text (e.g., "184+ sold")
sold_count	Integer parsed from sold_info ("2.1K+ sold" -> 2100)
sold_date	ISO-8601 date when listing sold - populated only in soldOnly mode
sold_date_text	Raw sold-date caption as displayed
is_sold	Bool - true for completed-sale listings
location	Seller location
domain	eBay domain used for scraping
source	Retrieval source, including ebay_search, ebay_detail, picclick_fallback, or search_index_fallback
data_completeness	Listing qualification; incomplete and discovery-only rows are excluded when requirePrice=true
search_query	Original search term
scraped_at	ISO 8601 timestamp of extraction

Sample Listing Item

{
    "itemId": "295854732101",
    "title": "Pokemon TCG Scarlet & Violet Booster Box - 36 Packs - Sealed",
    "url": "https://www.ebay.com/itm/295854732101",
    "price": 129.99,
    "price_text": "$129.99",
    "currency": "USD",
    "list_price": 159.99,
    "list_price_text": "$159.99",
    "shipping_cost": 0.0,
    "shipping_text": "Free shipping",
    "free_shipping": true,
    "condition": "New",
    "seller": "pokemon_central 99.8% positive (14.2K)",
    "seller_username": "pokemon_central",
    "seller_feedback_percentage": 99.8,
    "seller_feedback_count": 14200,
    "bids": null,
    "end_time": null,
    "time_left": null,
    "sold_price": null,
    "listing_type": "buy_it_now",
    "best_offer": false,
    "is_sponsored": false,
    "image_url": "https://i.ebayimg.com/images/g/abc123/s-l1600.webp",
    "sold_info": "184+ sold",
    "sold_count": 184,
    "location": "Los Angeles, CA",
    "domain": "ebay.com",
    "search_query": "pokemon cards",
    "scraped_at": "2026-04-18T10:15:00Z"
}

Sold-Listings Summary Item

When soldOnly=true, each run also emits a single sold_listings_summary item:

{
    "type": "sold_listings_summary",
    "search_query": "pokemon booster box",
    "domain": "ebay.com",
    "lookback_days": 90,
    "n_sold_listings": 100,
    "currency": "USD",
    "recommended_list_price": 129.95,
    "median_price": 119.50,
    "mean_price": 128.30,
    "p10_p90_range": {"p10": 65.00, "p25": 89.99, "p75": 149.99, "p90": 199.00},
    "price_range": {"min": 24.99, "max": 349.00},
    "median_days_to_sell": 18,
    "p90_days_to_sell": 62,
    "market_velocity": "hot",
    "confidence_score": 0.87,
    "date_coverage_ratio": 0.92,
    "sold_listings_trend": {
        "has_history": true,
        "price_delta_7d_pct": -2.1,
        "price_delta_30d_pct": 5.4,
        "volume_delta_pct": 12.0,
        "velocity_delta": "steady -> hot",
        "velocity_rank_delta": 1,
        "direction": "up",
        "sample_count_history": 14,
        "previous_recommended_list_price": 124.50
    },
    "generated_at": "2026-04-22T23:00:00Z",
    "methodology": "Sold-listings aggregation over eBay LH_Sold=1&LH_Complete=1 completed-sale filter"
}

Pricing

The event fees below are unchanged. From November 8, 2026 at 17:56 Europe/Amsterdam (16:56 UTC), Apify platform usage is billed separately in addition to these fees. Until that time, platform usage remains included in event pricing. Usage varies with runtime, memory, storage, data transfer and proxy use; it can be charged even if the run is blocked or returns no listings. Check the current and upcoming pricing in Apify Console before running.

Event	Price	Description
product-scraped	$0.003	Per live listing (auction or BIN) in default mode
sold-listing-scraped	$0.005	Per completed-sale listing in soldOnly mode
sold-summary-generated	$0.05	Once per run when the sold_listings_summary is emitted
sold-trend-detected	$0.03	Once per run when sold_listings_trend is populated from history (free on first run)
ai-analysis-completed	$0.05	Per AI market analysis report

Listing-event examples, excluding startup, default-dataset fees and any separately billed platform usage: 50 qualified active listings = $0.15. When completed-sale pages are reachable, 50 sold listings + summary (first run) = $0.30. Same with trend (subsequent runs) = $0.33. Diagnostic-only blocked runs do not charge listing or summary events. The existing startup event is $0.00005 per GB (minimum one event) and the default-dataset item event is $0.00001 per item. Owner test usage is not buyer revenue.

Quick Start

Test access with a single active-listing request:

{
    "searchQuery": "mechanical keyboard",
    "maxProducts": 1,
    "requirePrice": true,
    "ebayDomain": "ebay.com"
}

Run this in Apify Console, then inspect the result's source, price and currency. An empty default dataset is not a successful price check; open Diagnostics for the explanation. Increase the limit only after useful output is confirmed.

Advanced sold-listings test (JSON input only):

{
    "searchQuery": "pokemon booster box",
    "ebayDomain": "ebay.com",
    "soldOnly": true,
    "maxProducts": 3,
    "soldDateLookback": 90
}

Use this only after you have a proxy path that can reach eBay completed-sale pages. When reachable, it returns completed-sale records plus a sold_listings_summary; when blocked, it returns a diagnostic item instead.

Filtered auction search:

{
    "searchQuery": "vintage Rolex watch",
    "ebayDomain": "ebay.com",
    "listingType": "auction",
    "sortBy": "ending_soonest",
    "minPrice": 500,
    "maxPrice": 5000,
    "maxProducts": 50
}

Used electronics on eBay UK:

{
    "searchQuery": "MacBook Pro",
    "ebayDomain": "ebay.co.uk",
    "itemCondition": "used",
    "sortBy": "price_low",
    "maxProducts": 30
}

With AI market analysis:

{
    "searchQuery": "Nintendo Switch OLED",
    "maxProducts": 50,
    "enableAiAnalysis": true,
    "llmProvider": "openrouter",
    "openrouterApiKey": "sk-or-..."
}

Advanced direct product URL test (JSON input only):

{
    "productUrls": [
        "https://www.ebay.com/itm/123456789",
        "https://www.ebay.com/itm/987654321"
    ]
}

Proxy note: eBay is currently anti-bot sensitive from cloud and datacenter IPs. Start with maxProducts: 1-3, use a residential or premium proxy path, and match the exit country to the selected eBay domain before scaling.

MCP Quickstart - call this actor from Claude / Cursor / ChatGPT

Open Apify's hosted MCP server with this actor selected:

https://mcp.apify.com?tools=harvestlab/ebay-scraper

Then prompt the agent:

"Use the harvestlab/ebay-scraper actor on Apify to find active vintage Polaroid camera listings on ebay.co.uk with prices, shipping, seller fields, and item URLs. Push the results back as JSON."

Through Apify MCP, the agent can generate the right input, run the actor, and pipe the typed output back into your conversation.

Use with AI agents

ebay-scraper returns structured active-listing records with auction vs. Buy It Now status, bid count, seller feedback, currency, prices, and item URLs across 13 marketplaces. Use it as a single tool inside resale-arbitrage, price-discovery, or marketplace-monitoring workflows.

LangChain single-query tool

This optional runner is for your own already proven, authorized access path. The current owner checks have not recovered a useful eBay price feed; an SDK example does not change that status or establish source API approval. Start with one listing. Each invocation starts one paid Actor run, even if eBay blocks it. Startup charges apply; separately billed platform usage begins November 8, 2026 at 17:56 Europe/Amsterdam. The $0.10 limit below is an event-charge cap, not an all-in quote. Keep all existing access and billing warnings above.

The example uses typed apify-client 3.3/3.4 results and your existing LangChain installation. It accepts one query and an explicit canonical ebayDomain, bounds results to 1–10, and leaves sold listings, browser rendering, details and AI off. Supply only your own previously validated proxy configuration; none is invented or assumed to restore access.

from datetime import timedelta
from decimal import Decimal
import os
from apify_client import ApifyClient
from langchain_core.tools import tool

EBAY_DOMAINS = {"ebay." + suffix for suffix in (
    "com co.uk de fr it es com.au ca nl at ch ie pl"
).split()}
client = ApifyClient(os.environ["APIFY_TOKEN"])

@tool
def fetch_ebay_priced_listings(searchQuery: str, ebayDomain: str = "ebay.com",
                               maxProducts: int = 1, proxyConfiguration: dict | None = None) -> list[dict]:
    """Run one bounded active-listing search only after your access path is proven."""
    if not searchQuery.strip() or len(searchQuery) > 200:
        raise ValueError("Provide one nonempty query of at most 200 characters")
    if ebayDomain not in EBAY_DOMAINS or not 1 <= maxProducts <= 10:
        raise ValueError("Use a supported canonical ebayDomain and 1-10 results")
    run_input = {"searchQuery": searchQuery.strip(), "ebayDomain": ebayDomain,
                 "maxProducts": maxProducts, "requirePrice": True,
                 "useBrowser": False, "fetchDetails": False,
                 "soldOnly": False, "enableAiAnalysis": False}
    if proxyConfiguration is not None:
        run_input["proxyConfiguration"] = proxyConfiguration
    run = client.actor("harvestlab/ebay-scraper").call(
        run_input=run_input, memory_mbytes=4096,
        run_timeout=timedelta(seconds=120), max_total_charge_usd=Decimal("0.10"),
        restart_on_error=False,
    )
    if run is None or run.status != "SUCCEEDED":
        raise RuntimeError("No completed observation; retain your last accepted data")
    rows = list(client.dataset(run.default_dataset_id).iterate_items(limit=100))
    if not rows:
        raise RuntimeError(f"No priced listings in run {run.id}; inspect its Diagnostics output")
    return rows

# This would start one paid run; do not invoke until your own access is proven:
# listings = fetch_ebay_priced_listings.invoke({"searchQuery": "vintage polaroid sx-70",
#     "ebayDomain": "ebay.co.uk", "maxProducts": 1, "proxyConfiguration": your_validated_proxy})

requirePrice=true excludes partial and discovery-only rows; it does not prove that an indexed price is current or that inventory remains available. Empty Listings output is not a successful price check. Read the same run's Diagnostics output and preserve your last accepted data; do not automatically retry, scale or silently switch domains. AI is off and this wrapper sends no notifications.

LangGraph asking-price comparison

This graph performs no Actor calls. Give it listing rows from already completed, accepted requirePrice=true exports for the products you chose to compare. It checks basic listing identity, source, positive price and timestamp fields, then compares marketplace medians only when all accepted rows use the same currency and at least two marketplaces are represented. It does not reproduce the Actor's full qualification, verify source freshness or establish that different listings are comparable products.

The threshold is a percentage gap in observed asking prices. Shipping, taxes, condition, fees, exchange rates and realized profit are not included. Mixed currencies or too little evidence produce an explicit no-signal result, never an arbitrage or profit claim. This independent block needs only LangGraph; it does not need an Apify token, SDK client or the runner block above.

from datetime import datetime
from decimal import Decimal, InvalidOperation
import re
from statistics import median
from typing import TypedDict
from urllib.parse import urlsplit
from langgraph.graph import StateGraph, START, END

class PriceGapState(TypedDict, total=False):
    observations: list[dict]
    spread_threshold_pct: float
    comparison: dict

DOMAINS = {"ebay." + suffix for suffix in (
    "com co.uk de fr it es com.au ca nl at ch ie pl"
).split()}

def accepted_listing(row: dict) -> dict | None:
    try:
        if (not isinstance(row, dict) or row.get("diagnostic_item") or row.get("block_detected")
                or row.get("result_type") or row.get("error") or row.get("type")
                or row.get("data_completeness") or row.get("is_sold") or row.get("sold_date")
                or row.get("sold_date_text") or row.get("source") not in {"ebay_search", "ebay_detail", "picclick_fallback"}):
            return None
        if row["source"] == "ebay_detail" and row.get("listing_status") != "active":
            return None
        domain, currency = row["domain"], row["currency"]
        item_id = str(row.get("item_id") or row.get("itemId") or "")
        parsed = urlsplit(row["url"])
        match = re.fullmatch(r"/itm/(?:[^/]+/)?([0-9]{9,15})/?", parsed.path)
        price = Decimal(str(row["price"]))
        observed = datetime.fromisoformat(row["scraped_at"].replace("Z", "+00:00"))
        if (domain not in DOMAINS or (parsed.hostname or "").removeprefix("www.") != domain
                or parsed.scheme not in {"http", "https"} or parsed.username or parsed.password or parsed.port
                or not match or match.group(1) != item_id or not str(row.get("title") or "").strip()
                or not re.fullmatch(r"[A-Z]{3}", currency) or not price.is_finite() or price <= 0
                or observed.utcoffset() is None or row.get("listing_type") not in {
                    "auction", "buy_it_now", "buy_it_now_or_best_offer"}):
            return None
        return {"key": domain + ":" + item_id, "domain": domain, "currency": currency,
                "price": price, "observed": observed}
    except (KeyError, TypeError, ValueError, AttributeError, InvalidOperation):
        return None

def compare_prices(state: PriceGapState) -> dict:
    threshold = Decimal(str(state.get("spread_threshold_pct", 25)))
    rows = state.get("observations", [])
    if not threshold.is_finite() or threshold <= 0 or not isinstance(rows, list) or len(rows) > 1000:
        raise ValueError("Use a positive finite percentage and at most 1000 accepted rows")
    result = {"status": "insufficient_data", "currency": None, "medians": {},
              "price_gap_pct": None, "price_gap_alert": False, "accepted_listings": 0}
    # Select newest timestamps first; older conflicts cannot veto newer evidence.
    candidates = {}
    for item in rows:
        row = accepted_listing(item)
        if row is None:
            continue
        group = candidates.get(row["key"])
        if group is None or row["observed"] > group[0]["observed"]:
            candidates[row["key"]] = [row]
        elif row["observed"] == group[0]["observed"]:
            group.append(row)
    latest = {}
    for key, group in candidates.items():
        if len({(row["price"], row["currency"]) for row in group}) > 1:
            return {"comparison": dict(result, status="conflicting_observations")}
        latest[key] = group[0]
    if len({row["currency"] for row in latest.values()}) > 1:
        return {"comparison": dict(result, status="currency_conflict")}
    grouped = {}
    for row in latest.values():
        grouped.setdefault(row["domain"], []).append(row["price"])
    if len(grouped) < 2:
        return {"comparison": result}
    medians = {domain: median(values) for domain, values in grouped.items()}
    gap = (max(medians.values()) - min(medians.values())) * 100 / min(medians.values())
    return {"comparison": dict(result, status="observed", currency=next(iter(latest.values()))["currency"],
        medians={domain: str(value) for domain, value in medians.items()}, price_gap_pct=str(gap),
        price_gap_alert=gap >= threshold, accepted_listings=len(latest))}

builder = StateGraph(PriceGapState)
builder.add_node("compare", compare_prices)
builder.add_edge(START, "compare")
builder.add_edge("compare", END)
price_gap_graph = builder.compile()

# Replace this empty list with rows from your existing accepted exports.
# Empty input intentionally returns status="insufficient_data", not a price signal.
saved_listings = []
comparison = price_gap_graph.invoke({"observations": saved_listings, "spread_threshold_pct": 25})

price_gap_alert is only a same-currency asking-price gap for your review. The graph neither schedules work nor writes to a store, receiver or CRM. Currency conflicts need manual review; no currency conversion provider is called. A retrieval timestamp is not proof of an indexed listing's current checkout price.

Troubleshooting

Getting blocked or seeing empty results eBay's bot-detection is currently blocking many Apify-hosted search and item-page requests with HTTP 403. Active-listing runs try a fallback public listing index after the primary eBay fetch fails; sold-listings mode cannot use that fallback because completed-sale history is not exposed there. Try a premium residential/mobile proxy path, match the proxy country to the eBay domain, and validate with maxProducts: 1-3 before scaling.

For blocked or zero-result runs, open the run's Diagnostics output link and read the final status message. The default dataset remains empty when no listing is recovered, and diagnostics incur no product or dataset-item fee. Startup charges still apply, along with separately billed platform usage from November 8, 2026 at 17:56 Europe/Amsterdam. Recovery stops after 25 seconds without a successfully saved qualified priced listing. Partial and discovery-only rows do not extend that window. Listings already fetched can still be saved, but no new optional detail request starts after the recovery window expires. The configured proxy is used for both page requests and listing recovery; proxy configuration failures do not silently switch to direct requests.

Prices appear in the wrong currency eBay localizes prices based on the requesting IP's country. If you see EUR prices when you expected USD (or vice versa), your proxy exit node is landing in the wrong country. Set proxyConfiguration.apifyProxyCountry to the two-letter country code that matches your target domain - for example US for ebay.com, GB for ebay.co.uk, DE for ebay.de. The scraper maps each of the 13 supported domains to its canonical country automatically when you use Apify Proxy without a country override.

Sold-listings results are empty or very sparse First, confirm soldOnly: true is set in your input - without it, the scraper runs in live-listing mode. Second, check whether the product has recent sold history: narrow or niche listings may have fewer than 5 completed sales in eBay's ~90-day window. Try broadening the search query. Third, ensure you are using the correct domain - a search on ebay.de for an English-language query will return far fewer sold listings than the same search on ebay.com.

Seller information missing on auction listings Some auction cards omit seller information. fetchDetails=true attempts to add fields from the individual item page, at the cost of extra requests. Blocked or incomplete pages leave fields empty; enabling enrichment does not guarantee seller information.

Filtered primary search fails

Recovery is deliberately skipped for non-default condition or sort selections because the fallback indexes cannot honor those requirements. Keep the filters when they matter. Choose itemCondition: "any" and sortBy: "best_match" only when broader indexed results are acceptable. Detail pages declaring a different item or marketplace are discarded rather than merged into the requested listing.

AI analysis returns an error about a missing API key OpenRouter API key: set OPENROUTER_API_KEY env var OR openrouterApiKey input. Get one at openrouter.ai/keys. Anthropic: set ANTHROPIC_API_KEY env var OR anthropicApiKey input. Google AI: set GOOGLE_API_KEY env var OR googleApiKey input. OpenAI: set OPENAI_API_KEY env var OR openaiApiKey input. Ollama: ensure Ollama is running and accessible at the configured ollamaBaseUrl.

Cross-run trend block shows has_history: false This is normal on the first run for any (searchQuery, domain) pair. The first run seeds the history store; trend data (price_delta_7d_pct, velocity_delta, etc.) appears from the second run onward. The sold-trend-detected billing event ($0.03) fires only when history exists, so the first run is free on that dimension.

Maximum 100 products per run The actor caps results at 100 per search for PPE bill safety. For larger datasets, run the actor multiple times with different search queries or price-range filters to cover complementary market segments.

---

Scheduling and webhooks

Schedule daily price-watch runs in Apify Console to track eBay auction closing prices or BIN fluctuations for a target category. Wire a webhookUrl in n8n or Make to push deal alerts into a Slack channel or Telegram bot the moment a run finishes. Typical pipeline: "vintage Lego set 10179" daily eBay run -> n8n -> Slack alert when price drops below threshold.

---

Legal and Compliance

This actor scrapes publicly available data from eBay. Users are responsible for:

• Complying with eBay's Terms of Service
• Adhering to applicable data protection laws (GDPR, CCPA, and local equivalents)
• Using extracted data in accordance with all relevant regulations
• Ensuring their use case does not violate any local or international laws

eBay scraping policy: eBay's User Agreement restricts automated access to its platform. Users are solely responsible for ensuring their use case complies with eBay's Terms of Service and any applicable API policies. This actor is provided as a technical tool; compliance obligations rest with the user.

GDPR and seller personal data: eBay seller profiles (username, feedback percentage, feedback count, location) constitute personal data under GDPR for EU-resident sellers. If you process data of individuals in the EU, you must have a lawful basis for processing, honor data-subject access and deletion requests, and avoid retaining seller personal data beyond your stated purpose.

Request limits: the actor inserts 1-2.5 second delays between pages, bounds individual fetches and stops a recovery phase after 25 seconds without a successfully saved qualified priced listing. Partial and discovery-only rows do not renew the recovery budget. The PicClick fallback stops after HTTP 403 or 429 instead of repeatedly retrying a rejected host. These limits do not establish permission to scrape or guarantee access.

Data retention guidance: scrape outputs may include seller usernames, feedback scores, and item locations. Establish a retention policy aligned with your use case - for price-monitoring workloads a 90-day rolling window is typically sufficient. Delete or anonymize data no longer needed for your stated purpose.

For questions or concerns, use this Actor's Issues tab in Apify Store. Include the run ID and a description of the missing or incorrect fields; do not post credentials.

Related Actors

• Amazon Scraper - pair eBay sold-comp data with Amazon catalog prices across 11 marketplaces for cross-platform arbitrage signals.
• Product Hunt Scraper - surface early product trends on Product Hunt before they hit eBay reseller demand cycles.