# eBay Motors Vehicle & Parts Scraper (`w3crawler/ebay-motors-scraper`) Actor

Extract publicly visible eBay Motors listings for cars, trucks, motorcycles, boats, RVs, ATVs, and parts. Search by keyword, vehicle type, condition, price range, and year. Returns listing details or fail-closed access diagnostics when public evidence is unavailable.

- **URL**: https://apify.com/w3crawler/ebay-motors-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 vehicle listings

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

### What does eBay Motors Vehicle & Parts Scraper do?

**eBay Motors Vehicle & Parts Scraper** extracts evidence-backed, publicly visible listing data from [eBay Motors](https://www.ebay.com/motors) through direct public HTTP requests. It provides structured output through the Apify **API** and dataset interfaces for vehicles, motorcycles, boats, RVs, ATVs, and parts.

The Actor only publishes information found on the requested public eBay page. It has no eBay developer credential fields and no official-API runtime path. It uses a bounded anonymous session established through eBay's public help page; it does not use mirrors, private endpoints, login sessions, or access-control bypasses. If eBay presents a CAPTCHA, login wall, paywall, geofence, rate limit, device/browser check, WAF page, or another access boundary, the Actor stops for that target and emits a diagnostic row instead of inventing or substituting data. Browser-visible attributes are optional and omitted when the page does not disclose them.

### Why use eBay Motors Vehicle & Parts Scraper?

- Search public eBay Motors listings by keyword and category.
- Generate marketplace-specific Motors searches for eBay US, UK, or Germany.
- Filter returned evidence by condition, price range, and model year.
- Reject promoted accessories, die-cast models, manuals, service kits, and other non-vehicle rows from vehicle searches.
- Optionally enrich up to 20 generated results from their public item pages while retaining useful card data when detail access is unavailable.
- Scrape explicitly supplied public item URLs in `byListingUrls` mode.
- Receive bounded, normalized records with backward-compatible `url`, `priceFormatted`, and `listingType` fields.
- Run on a schedule, access results through the Apify API, connect datasets to integrations, and monitor failures in Apify Console.

The Actor uses one public request at a time with bounded timeouts, a 12 MB streaming response cap, a short pacing delay, and at most one retry for transient network failures. Optional `proxyConfiguration` is honored, and `usedProxy` records the actual route. It does not retry access-control responses.

### What data can eBay Motors Vehicle & Parts Scraper extract?

| Field | Type | Description |
|---|---|---|
| `itemId` / `itemUrl` | string | Public eBay listing identifier and URL when present. |
| `title` | string | Public listing title. |
| `price` / `priceNumeric` | string / number | Displayed price and parsed numeric value. |
| `condition` | string | Public listing condition. |
| `year`, `make`, `model`, `trim`, `vin` | number / string | Vehicle identity when present. |
| `mileage` | number | Public mileage or odometer value. |
| `engine`, `transmission`, `drivetrain`, `fuelType`, `bodyStyle` | string | Public mechanical and body attributes. |
| `exteriorColor`, `interiorColor`, `doors`, `seats` | mixed | Additional public vehicle attributes. |
| `detailStatus`, `detailUrl`, `searchSourceUrl` | string | Detail-enrichment outcome and provenance. |
| `seller`, `location`, `shipping`, `images` | object / array / string | Bounded public listing details when present. |
| `found`, `dataAvailable` | boolean | Evidence and availability flags. Diagnostic rows set both to `false`. |
| `accessStatus`, `diagnosticCode` | string | Explanation for a fail-closed row. |

Optional values are omitted when the public page does not provide them. The dataset schema documents every field the runtime can emit.

### How to scrape eBay Motors

1. Open the Actor's **Input** tab.
2. Select `searchVehicles`, `searchParts`, or `byListingUrls`.
3. For a search, provide a query and any category, condition, price, year, sort, and result-limit controls.
4. For `byListingUrls`, provide public eBay item URLs such as `https://www.ebay.com/itm/100000000001`.
5. Start with a small `maxItems` value, run the Actor, and inspect the dataset and any diagnostic rows.

Search mode requests one public eBay search page and, by default, enriches up to `maxDetailPages` accepted vehicle cards from their public item pages. A generated vehicle must expose a plausible model year and a vehicle signal, and known promoted-part patterns are rejected before enrichment. The site may return fewer listings than the requested maximum. Listing-URL mode processes supplied item pages sequentially until the requested maximum is reached.

### How much will it cost to scrape eBay Motors?

You pay for the Actor's Apify compute usage. Actual duration depends on the number of requested URLs, response size, and any bounded network retry. Start with a small input to estimate cost before running a larger collection.

### Input

See the **Input** tab for the complete configuration. Controls include mode, marketplace, search query, vehicle and parts categories, condition, sorting, marketplace-currency price bounds, year bounds, public start URLs, maximum items, `includeDetails`, and `maxDetailPages`.

### Output

You can download the dataset in formats such as JSON, HTML, CSV, or Excel. A successful listing row has `found: true` and `dataAvailable: true`. When public evidence is unavailable, the Actor returns a row with `found: false` and `dataAvailable: false`, along with `accessStatus`, `diagnosticCode`, HTTP status, and a short sanitized response preview when available. This Actor writes to the dataset only; it does not write key-value-store records.

```json
[
  {
    "recordType": "ebay-motors-listing",
    "found": true,
    "dataAvailable": true,
    "itemUrl": "https://www.ebay.com/itm/100000000001",
    "title": "Example 2018 Sedan Listing",
    "price": "$18,500",
    "year": 2018
  },
  {
    "recordType": "ebay-motors-access-diagnostic",
    "found": false,
    "dataAvailable": false,
    "accessStatus": "captcha_or_human_check",
    "diagnosticCode": "page_challenge"
  }
]
```

### Tips and advanced options

The lifecycle entrypoint is `src/main.js`; `src/actor.js` owns Apify initialization and shutdown, while `src/runner.js` contains public request, listing extraction, filtering, diagnostics, and dataset output.

- Start with one search or one item URL and a low `maxItems` value.
- Treat access diagnostics as a boundary; do not attempt to work around them.
- Use explicit item URLs when you need evidence from known public listings.
- Keep the requested filters aligned with the public fields you expect to find.

### Key-value store

The actor does not write custom key-value records. Listing and access-diagnostic rows are stored in the dataset; the declared key-value store is intentionally empty.

### FAQ, disclaimers, and support

#### Does this Actor scrape private data?

No. It processes public page evidence only and does not defeat authentication, access controls, paywalls, CAPTCHAs, or WAF restrictions.

#### What should I do when a diagnostic row appears?

Review `accessStatus` and `diagnosticCode`, reduce the request size, and respect the target's access controls. Persistent restrictions are reported as limitations rather than bypassed.

#### Data-protection notice

Our Actors are ethical and do not intentionally extract private user data. They only process information available on public pages. Results can still contain personal data protected by the GDPR and other laws. Do not process personal data without a legitimate reason; consult legal counsel if uncertain.

For feedback, use the Actor's Issues tab. For programmatic use, open the API tab in Apify Console.

# Actor input Schema

## `market` (type: `string`):

Official marketplace used for generated public Motors searches.

## `mode` (type: `string`):

Choose what to scrape: search for vehicles, search for parts, or enrich specific listing URLs.

## `searchQuery` (type: `string`):

Keyword(s) to search for (optional). When empty, browses trending vehicles in the selected category. Example: 'toyota camry', 'honda civic'.

## `vehicleType` (type: `string`):

Category of vehicle to search (used in searchVehicles mode).

## `partCategory` (type: `string`):

Category of parts to search (used in searchParts mode).

## `condition` (type: `string`):

Filter listings by condition.

## `sortBy` (type: `string`):

How to sort the search results.

## `minPrice` (type: `integer`):

Minimum listing price in the selected marketplace currency.

## `maxPrice` (type: `integer`):

Maximum listing price in the selected marketplace currency.

## `minYear` (type: `integer`):

Minimum model year (e.g., 2015).

## `maxYear` (type: `integer`):

Maximum model year (e.g., 2024).

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

Specific eBay Motors listing URLs to scrape (used in byListingUrls mode). Each should be an eBay item URL like https://www.ebay.com/itm/123456789.

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

Maximum number of listings to scrape.

## `includeDetails` (type: `boolean`):

Open bounded public item pages for make, model, trim, VIN, mileage, engine, transmission, drivetrain, fuel, body, colours, doors and seats.

## `maxDetailPages` (type: `integer`):

Maximum generated-search results enriched from public item pages.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy route for public eBay Motors pages. Every output row reports whether it was used.

## Actor input object example

```json
{
  "market": "us",
  "mode": "searchVehicles",
  "vehicleType": "cars-trucks",
  "partCategory": "car-truck-parts",
  "condition": "all",
  "sortBy": "best-match",
  "startUrls": [],
  "maxItems": 50,
  "includeDetails": true,
  "maxDetailPages": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing public listing records plus diagnostics when access or listing evidence is unavailable.

# 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 = {
    "market": "us",
    "mode": "searchVehicles",
    "vehicleType": "cars-trucks",
    "partCategory": "car-truck-parts",
    "condition": "all",
    "sortBy": "best-match",
    "startUrls": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/ebay-motors-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 = {
    "market": "us",
    "mode": "searchVehicles",
    "vehicleType": "cars-trucks",
    "partCategory": "car-truck-parts",
    "condition": "all",
    "sortBy": "best-match",
    "startUrls": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/ebay-motors-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 '{
  "market": "us",
  "mode": "searchVehicles",
  "vehicleType": "cars-trucks",
  "partCategory": "car-truck-parts",
  "condition": "all",
  "sortBy": "best-match",
  "startUrls": [],
  "maxItems": 50
}' |
apify call w3crawler/ebay-motors-scraper --silent --output-dataset

```

## MCP server setup

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