# eBay Scraper — Full Product Specifics (`api-empire/ebay-scraper`) Actor Scrape eBay product details including titles, prices, descriptions, images, item specifics, seller information, ratings, availability, shipping, and categories. Build structured datasets for product research, competitor analysis, pricing intelligence, and e-commerce insights. - **URL**: https://apify.com/api-empire/ebay-scraper.md - **Developed by:** [API Empire](https://apify.com/api-empire) (community) - **Categories:** E-commerce, Automation, Developer tools - **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.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/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### eBay Scraper — Extract Listings, Specifics & Seller Data as JSON eBay Scraper — Full Product Specifics turns eBay search-result and single-listing pages into structured JSON: full product listings, every item-specifics label-value pair, a full-resolution image gallery, and seller feedback data in one row per item. Every response returns typed, normalized JSON — no HTML, no selectors, no parsing. An optional AI condition-consistency check flags listings where the free-text description contradicts the claimed condition badge. Point it at a search URL or a single listing link, and you'll have a spec-level product dataset ready for research, sourcing, or an LLM pipeline. ### What is eBay Scraper — Full Product Specifics? eBay Scraper — Full Product Specifics is an Apify Actor that reads public eBay search-result and `/itm/` listing pages and returns each product as a structured JSON row — including the complete item-specifics table, a full-resolution image gallery, and seller feedback figures. No eBay account or login is required; it fetches the same publicly visible listing page a logged-out browser would see. It's callable through the Apify API from any script or agent framework, so it drops into automated pipelines without a browser in the loop. - Scrape product listings from eBay search/category URLs or single `/itm/` links - Scrape the full item-specifics dict — every label→value pair the listing page shows, not just a handful of derived columns - Scrape seller feedback data — feedback count and positive-% alongside the product row - Export as JSON, CSV, or any other Apify dataset format - No proxy management required — built-in Chrome TLS impersonation handles most runs; Apify Proxy is optional ### What data does eBay Scraper — Full Product Specifics collect? A single run can return four kinds of data for every listing it processes: the core product record, the full item-specifics table, the image gallery, and seller feedback figures. | Data Type | Key Fields | JSON Field Names | | --- | --- | --- | | Product listing | title, price, condition, buying format, availability, sold count | `title`, `price`, `priceWithCurrency`, `condition`, `buyingFormat`, `available`, `sold` | | Item specifics | brand, type, MPN/UPC/EAN, and the full label→value spec table (Processor, RAM, Screen Size, Connectivity, and whatever else the listing shows) | `brand`, `type`, `mpn`, `upc`, `ean`, `itemSpecifics` | | Images | full-resolution photo gallery from the carousel and product-image list | `image`, `images` | | Seller & feedback | seller username, total feedback count, positive-feedback percentage, item location | `seller`, `sellerFeedbackCount`, `sellerPositivePercent`, `itemLocation` | | AI condition check (optional) | consistency verdict, confidence, explanation | `conditionConsistency` | #### Need more eBay data? If you need deeper seller-side data instead of per-listing feedback figures, **eBay Seller Scraper : Reviews & Feedback Analytics** collects a seller's full paginated buyer-feedback history — reviewer names, rating types, comment text, verified-purchase flags, and photo counts — plus computed feedback analytics like review velocity and a positive/neutral/negative breakdown. It sits alongside this Actor under the same account and shares its no-login, public-data-only design. ### How does eBay Scraper — Full Product Specifics differ from the official eBay API? eBay's own Developer Program exposes catalog data through APIs such as the Browse API and the legacy Finding API, but using them requires a registered developer account, an application, and an OAuth access token on every call — eBay Scraper — Full Product Specifics reads the same public listing page and needs none of that. | Feature | eBay Developer API | eBay Scraper — Full Product Specifics | | --- | --- | --- | | Setup | Register a developer account, create an application, get approved for the API you need | Add eBay URLs and start the run | | Credentials | OAuth access token per application | None | | Item specifics coverage | Structured fields defined by eBay's own category schema | Every label→value pair the listing page actually displays, whatever the category | | Full-resolution images | Whatever image fields that API response includes | Full carousel + product-image list, deduped, upgraded to your chosen resolution | | Seller feedback | Requires a separate call with its own auth | Included in the same row, as feedback count and positive-% | | Full description text | Available through documented API fields | Optional verbatim full description text, one input toggle away | | AI enrichment | Not a feature of the eBay API | Optional AI condition-consistency check across several AI providers | The Developer Program API is the right choice when building an approved application under eBay's platform rules, using only the fields your access level exposes. eBay Scraper — Full Product Specifics fits better for the full item-specifics table, images, and seller feedback on arbitrary public listings, with no app-approval process. ### Why do developers and teams scrape eBay? eBay listing data supports a wider range of work than shopping comparison alone — sourcing, pricing research, and AI pipelines all draw on the same specifics-level fields this Actor returns. #### For dropshippers and resale sourcing teams Sourcing teams use the full `itemSpecifics` table, `images[]` gallery, and `condition`/`sellerNotes` fields to populate their own store listings without opening each eBay page by hand. A typical workflow runs a category search URL, caps `maxListings` at the batch size needed, and pulls `price`, `brand`, `type`, and the full spec dict straight into a product-import pipeline. Because `itemSpecifics` captures whatever labels the source listing actually carries — Processor, Screen Size, Connectivity, Country of Origin, and more — resellers don't lose category-specific attributes that a fixed-column export would drop. #### For pricing analysts and market researchers Analysts track `price`, `wasPrice`, `available`, and `sold` across a category or a set of competing listings to see how pricing and stock move over time. Running the same search URL on a schedule and comparing `priceWithCurrency` and `sold` between runs surfaces markdown patterns and demand signals without manually revisiting each listing. `categories` (the breadcrumb trail) lets the same dataset be sliced by product category, and `condition` alongside `price` separates new-condition premiums from used-market discounting within the same export, all without opening a single listing page by hand. #### For AI engineers and agent builders `itemSpecifics`, `title`, and `itemDescription` are natural inputs for a RAG index or a shopping agent's tool call — an engineer can embed the spec dict and description text per listing, then let an agent answer "which laptops have at least 8GB RAM and are rated Used" directly from indexed fields. Because every field is typed JSON rather than scraped HTML, it can be piped into an embedding step or agent tool without a parsing layer, and the optional `conditionConsistency` field gives an agent a pre-computed trust signal on top of the raw text. #### For developers building data products Developers building price-tracking dashboards or catalog-monitoring tools schedule runs against a fixed set of listing or search URLs and serve `price`, `available`, `sold`, and `sellerFeedbackCount` trends through their own product. Because each run appends fresh dataset rows with a stable schema, the same pipeline can be scheduled on Apify and queried through the Apify API without building or maintaining scraping infrastructure in-house — a REST call and a dataset ID are all a downstream product needs to stay current. ### How to scrape eBay (step by step) 1. Open **eBay Scraper — Full Product Specifics** on its Apify Store listing (or in Apify Console). 2. Add at least one eBay search or `/itm/` listing URL to `productListingUrls` — the run stops with zero output rows if this is left empty. 3. Set `maxListings` to cap how many listings get fully processed, and toggle `imageResolution`, `fetchFullDescription`, or `aiConditionCheck` as needed. 4. Start the run — no eBay login, cookies, or app credentials required. 5. Open the Dataset tab and export results as JSON or CSV, or pull them through the Apify API. #### What to do when eBay changes its structure eBay Scraper — Full Product Specifics is actively maintained, with selector fallbacks already built in for markup eBay has changed before (its search-result card markup, for one). The output schema stays stable, so integrations keep working even after an eBay page-markup update. No specific fix turnaround is guaranteed. ### ⬇️ Input | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `productListingUrls` | No | array | eBay search-result or `/itm/` listing URLs. Search/category pages are discovered into individual listings; `/itm/` links are scraped directly. (`urls` from the base actor also works.) | `["https://www.ebay.com/sch/i.html?_nkw=laptop"]` | | `maxListings` | No | integer | Ceiling on how many product pages to fully process. `0` = no limit. Console prefill is `20`; if the key is omitted entirely from a raw API call it is treated as `0` (no cap). Minimum `0`, maximum `100000`. (`maxItems` also works.) | `20` | | `imageResolution` | No | string (enum) | Resolution applied to every URL in the `images[]` gallery: `s-l1600` (full resolution, default), `s-l500` (medium), `s-l140` (thumbnail). | `"s-l1600"` | | `fetchFullDescription` | No | boolean | When `true`, adds the listing's full free-text description as `itemDescription` — costs one extra request per listing when the text isn't already inline. Default `false`. | `true` | | `aiConditionCheck` | No | boolean | When `true`, compares the claimed `condition` against seller notes/description text and adds `conditionConsistency`. Requires `aiApiKey`. Default `false`. | `false` | | `aiModel` | No | string (enum) | AI model/provider, used only when `aiConditionCheck` is on. Provider is auto-detected from the model name prefix (`claude-*`, `gpt-*`, `gemini-*`, `grok-*`, `deepseek-*`, `sonar*`, `mistral-*`). Default `"claude-haiku-4-5"`. | `"claude-haiku-4-5"` | | `aiApiKey` | No | string (secret) | API key for the selected AI provider. Falls back to the matching environment variable (e.g. `ANTHROPIC_API_KEY`) if left blank. Ignored when `aiConditionCheck` is off. | `"sk-ant-..."` | | `proxyConfiguration` | No | object | Apify Proxy settings for smoother runs against eBay's Akamai bot gate. Console prefill is `{"useApifyProxy": true}`. | `{"useApifyProxy": true}` | | `concurrency` | No | integer | How many listing pages to fetch in parallel. Minimum `1`, maximum `50`. Default `4`. | `4` | | `requestDelaySeconds` | No | integer | Base delay (plus random jitter) added before each product fetch, in seconds. Minimum `0`, maximum `60`. Default `1`. | `1` | Example input: ```json { "productListingUrls": ["https://www.ebay.com/sch/i.html?_nkw=laptop"], "maxListings": 20, "imageResolution": "s-l1600", "fetchFullDescription": true, "aiConditionCheck": false, "aiModel": "claude-haiku-4-5", "aiApiKey": "", "proxyConfiguration": { "useApifyProxy": true }, "concurrency": 4, "requestDelaySeconds": 1 } ``` The most common input mistake is leaving `productListingUrls` empty — the Actor logs an error and ends the run immediately, producing zero output rows, since it has no schema-level `required` fields to enforce this for you. ### ⬆️ Output Results are written as typed, normalized JSON dataset rows, one row per listing, saved live as each product finishes processing. Export from the Dataset tab as JSON or CSV, or pull results through the Apify API. Only successful product rows are billed under the `row_result` charged event; rows for listings that failed to load or parse are pushed without a charged event, so they don't add to run cost. #### Scraped product listing ```json { "url": "https://www.ebay.com/itm/336637594692", "itemNumber": "336637594692", "title": "Toshiba Satellite C55 15.6\" Laptop Intel Core i5 8GB RAM 256GB SSD Windows 10", "subTitle": "Fast, reliable laptop for work, school, or everyday browsing", "condition": "Used", "buyingFormat": "Buy It Now (Best Offer accepted)", "price": 129.99, "priceWithCurrency": "US $129.99", "wasPrice": 189.99, "wasPriceWithCurrency": "US $189.99", "available": 4, "availableText": "4 available", "sold": 27, "image": "https://i.ebayimg.com/images/g/abcAAOSw000/s-l1600.jpg", "images": [ "https://i.ebayimg.com/images/g/abcAAOSw000/s-l1600.jpg", "https://i.ebayimg.com/images/g/defAAOSw111/s-l1600.jpg", "https://i.ebayimg.com/images/g/ghiAAOSw222/s-l1600.jpg" ], "seller": "ticktockdeals", "sellerFeedbackCount": 60371, "sellerPositivePercent": 98.4, "itemLocation": "Newark, Ohio, United States", "brand": "Toshiba", "type": "Laptop", "categories": ["Computers/Tablets & Networking", "Laptops & Netbooks"], "ean": null, "mpn": "C55-B5299", "upc": "Does not apply", "sellerNotes": "Tested and working. Minor scuffs on lid, screen is clean. Battery holds a charge.", "itemSpecifics": { "Condition": "Used", "Seller Notes": "Tested and working. Minor scuffs on lid, screen is clean. Battery holds a charge.", "Brand": "Toshiba", "Type": "Laptop", "Processor": "Intel Core i5 5th Gen.", "Screen Size": "15.6 in", "RAM Size": "8 GB", "Model": "Satellite C55", "Connectivity": "Wi-Fi, Bluetooth, HDMI, USB 3.0", "Operating System": "Windows 10", "SSD Capacity": "256 GB", "Storage Type": "SSD", "MPN": "C55-B5299" }, "itemDescription": "This laptop has been fully tested and is in great working condition. Battery lasts several hours on a full charge...", "conditionConsistency": { "consistent": true, "confidence": "high", "explanation": "Description confirms used condition matching the claimed badge; no brand-new language found." }, "whyToBuy": ["Free shipping", "30 day returns accepted", "Ships same business day"], "scrapedAt": "2026-07-25T09:12:44.123Z" } ``` #### Failed listing rows (uncharged placeholder) ```json { "url": "https://www.ebay.com/itm/999999999999", "error": "unavailable", "errorReason": "http:404", "scrapedAt": "2026-07-25T09:13:02.501Z" } ``` ### How many results can you scrape with eBay Scraper — Full Product Specifics? `maxListings` accepts `0` (no cap enforced by the Actor itself) up to `100000`, applied as a total ceiling across all listings discovered from your input URLs. There's an important practical limit to know: each search/category URL is read as a single page — the Actor does not automatically walk eBay's own "next page" pagination for you. To collect more than one page of search results, add each page as its own entry in `productListingUrls` (for example, using eBay's own page-number URL parameter). `concurrency` (1–50) controls how many listing pages are fetched in parallel and affects run speed, not the total number of results. There is no benchmark for how long a given run takes, since that depends on how many listings you target and how eBay's anti-bot gate responds on a given run. ### Integrate eBay Scraper — Full Product Specifics and automate your workflow eBay Scraper — Full Product Specifics works with any language or tool that can send an HTTP request, since it runs as a standard Apify Actor. #### REST API integration ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("/ebay-scraper-full-product-specifics").call( run_input={ "productListingUrls": ["https://www.ebay.com/sch/i.html?_nkw=laptop"], "maxListings": 20, } ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): if "error" not in item: print(item["itemNumber"], item["title"], item["price"]) ``` Works in Python, Node.js, Go, Ruby, cURL — any client that can call the Apify API with your token. #### MCP for AI agents Apify's MCP server (`mcp.apify.com`) exposes Apify Actors — including this one — as callable tools for MCP-compatible clients such as Claude Desktop, Cursor, and Windsurf. Add the Actor's name, as shown on its Apify Store page, to the server's actor list to make it callable as an agent tool without writing custom integration code. #### Automation platforms (n8n, Make, LangChain) In **n8n**, the community Apify node's "Run Actor" operation can call eBay Scraper — Full Product Specifics by Actor ID, pass `productListingUrls`/`maxListings` as JSON, and feed the resulting dataset rows into downstream nodes. In **Make**, the Apify app's "Run an Actor or Task" module runs the same Actor and lets you map each returned row (`title`, `price`, `itemSpecifics`, `images`) into another scenario step, such as a spreadsheet or a Slack message. Any LangChain agent that can call an HTTP tool can invoke the Actor through the Apify API and consume its dataset items directly as typed JSON, without a parsing step. ### Is it legal to scrape eBay? Scraping publicly accessible eBay listing data is generally lawful, and eBay Scraper — Full Product Specifics only returns listing content that any logged-out visitor can already see on the page. Product data — titles, prices, item specifics, images, category breadcrumbs — is business/product data governed primarily by eBay's Terms of Service and database-rights considerations rather than personal-data law. The `seller` field reflects a store or account username displayed publicly on the listing itself; if that or any other output is treated as personal data in your jurisdiction, GDPR/CCPA-style rules on lawful basis for storage and use may still apply. Consult legal counsel for commercial use cases involving bulk personal data. ### Frequently asked questions #### Does eBay Scraper — Full Product Specifics work without an eBay account? Yes. No eBay login, cookies, or app credentials are required — the Actor reads the same publicly visible listing and search pages a logged-out browser can see, using a session warm-up to collect cookies before fetching. #### How often is the scraped data updated? Each run fetches live data directly from eBay's listing and search pages at run time; nothing is served from a cache, so results reflect whatever is publicly visible at the moment the run executes. #### What happens if a listing is delisted, removed, or fails to load? The Actor still writes a placeholder row for that URL with `error` and `errorReason` fields (for example, an HTTP 404 or a transport failure) and `scrapedAt`, so you can see exactly which listings failed, while the rest of the run continues normally. #### Can I scrape login-gated or member-only eBay content? No. Only publicly accessible search-result and listing pages are returned — content that requires signing into an eBay account to view is not accessible through this Actor. #### Does eBay Scraper — Full Product Specifics work for AI agent workflows and LLM pipelines? Yes. It's callable as an HTTP endpoint through the Apify API from any agent framework, and it's also registrable as a tool through Apify's MCP server. Every response is typed JSON with stable field names — no HTML and no parsing step before passing results to an LLM. #### How does eBay Scraper — Full Product Specifics handle eBay's anti-bot system? It uses `curl_cffi` to impersonate a real Chrome TLS/HTTP2 fingerprint against eBay's Akamai bot manager, warms up a session with a homepage request to collect cookies first, retries on thin-shell or "Pardon Our Interruption" JS-challenge responses after a short backoff, and falls back from Apify Proxy to a direct connection if the proxy becomes unreachable mid-run. #### Does eBay Scraper — Full Product Specifics return data in a format LLMs can use directly? Yes. Output is typed, normalized JSON with stable field names, so it can be passed directly into an LLM context window, indexed into a vector store, or routed through an agent tool without extra parsing. #### Can I use eBay Scraper — Full Product Specifics without managing proxies? Yes. The Actor's Chrome TLS impersonation and session warm-up handle most runs on their own; Apify Proxy is an optional add-on for smoother runs against eBay's bot gate, not a requirement. #### Which dataset rows count toward usage? Only complete product rows are billed, as a `row_result` charged event. Placeholder rows for listings that failed to load or parse (identifiable by the presence of an `error` field) are pushed with no charged event, so they don't add to run cost. #### What happens when eBay changes its structure or blocks the scraper? The Actor is actively maintained, and its output schema stays stable — field names and types don't change on your end because of an eBay-side update. No specific turnaround time is guaranteed for fixes. ### Your feedback Found a bug, or a field that's missing from your results? We want to know. Report it through the Issues tab on this Actor's Apify Store page, or reach out to API-Empire through Apify Console — active reports directly shape what gets fixed and maintained next. # Actor input Schema ## `productListingUrls` (type: `array`): 🗺️ One or many eBay links. 🔎 Search / category pages → we discover listings from the results grid. 🏷️ Single `/itm/` listing pages → we grab that item's full specifics directly. (Base-compatible: the old `urls` key still works if you have existing input JSON.) ## `maxListings` (type: `integer`): 📊 Ceiling on how many product pages to fetch full specifics for. 0️⃣ = no limit. (Base-compatible: `maxItems` still works.) Default is 20 when left blank. ## `imageResolution` (type: `string`): 🔍 Every photo in the listing's carousel + ld+json image list is upgraded to this resolution (eBay serves the same photo at multiple sizes via the `s-l` URL segment). Default: s-l1600 (full-res, largest available). ## `fetchFullDescription` (type: `boolean`): 📄 When ON, adds the listing's full free-text description as `itemDescription`. Needs one extra request per listing to eBay's description sub-page when the text isn't already inline on the main page. Default: OFF. ## `aiConditionCheck` (type: `boolean`): 🧪 Compares the claimed `condition` (e.g. "Used") against the seller notes / full description text and flags a mismatch (e.g. badge says Used but text says brand-new/sealed). Adds `conditionConsistency` = {consistent, confidence, explanation}. Requires `aiApiKey`. Default: OFF. ## `aiModel` (type: `string`): Only used when 🤖 AI condition check is ON. Provider auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-\*=Mistral. Cheaper mini/flash/haiku models are recommended. ## `aiApiKey` (type: `string`): Only used when 🤖 AI condition check is ON. Falls back to an env var matching your chosen provider (ANTHROPIC\_API\_KEY / OPENAI\_API\_KEY / GEMINI\_API\_KEY / XAI\_API\_KEY / DEEPSEEK\_API\_KEY / PERPLEXITY\_API\_KEY / MISTRAL\_API\_KEY) if left blank. ## `proxyConfiguration` (type: `object`): 🛡️ Optional Apify Proxy settings for smoother runs when eBay's Akamai gate is picky about traffic. ## `concurrency` (type: `integer`): ⚙️ How many listing pages to fetch at the same time (1–50). Lower = gentler on eBay's anti-bot defenses; higher = faster runs. ## `requestDelaySeconds` (type: `integer`): ⏱️ A small base delay (plus random jitter) added before each product fetch, to look less like a burst of bot traffic. ## Actor input object example ```json { "productListingUrls": [ "https://www.ebay.com/sch/i.html?_nkw=laptop" ], "maxListings": 20, "imageResolution": "s-l1600", "fetchFullDescription": false, "aiConditionCheck": false, "aiModel": "claude-haiku-4-5", "proxyConfiguration": { "useApifyProxy": true }, "concurrency": 4, "requestDelaySeconds": 1 } ``` # Actor output Schema ## `results` (type: `string`): All scraped items in the Actor's default dataset. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "productListingUrls": [ "https://www.ebay.com/sch/i.html?_nkw=laptop" ], "maxListings": 20, "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("api-empire/ebay-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "productListingUrls": ["https://www.ebay.com/sch/i.html?_nkw=laptop"], "maxListings": 20, "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("api-empire/ebay-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 '{ "productListingUrls": [ "https://www.ebay.com/sch/i.html?_nkw=laptop" ], "maxListings": 20, "proxyConfiguration": { "useApifyProxy": true } }' | apify call api-empire/ebay-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-empire/ebay-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 ` 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/vK3AWE0nd6v1QuDWU/builds/k7rNfh0oEDNaViWWB/openapi.json