# Proxibid Lots Search Scraper (`stealth_mode/proxibid-lots-search-scraper`) Actor

Scrape auction listings from ProxiBid search pages effortlessly. This scraper collects titles, prices, auction house details, images, and lot metadata from cars, real estate, collectibles, and more — perfect for market researchers, resellers, and auction data analysts.

- **URL**: https://apify.com/stealth\_mode/proxibid-lots-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## ProxiBid Lots Search Scraper: Extract Auction Listings Instantly

---

### What Is ProxiBid?

ProxiBid is one of the world's largest online auction marketplaces, hosting millions of lots from thousands of licensed auctioneers worldwide. From vehicles and real estate to collectibles and surplus inventory, ProxiBid connects buyers with diverse auction houses globally. Manually scrolling through search results to collect competitive pricing and market data is inefficient — the **ProxiBid Lots Search Scraper** automates bulk data collection, transforming search results into structured, actionable records.

---

### Overview

The **ProxiBid Lots Search Scraper** extracts auction listing data from ProxiBid category or search pages, compiling essential lot information into clean, machine-readable records. It is ideal for:

- **Resellers & dealers** monitoring market prices and supply trends
- **Auction analysts** tracking pricing patterns across auctioneers
- **Market researchers** studying online auction dynamics
- **Business intelligence teams** building competitive datasets

Key advantages include configurable item limits, robust failure handling with `ignore_url_failures`, and detailed lot metadata spanning auction house, pricing, imagery, and timing information.

---

### Input Format

The scraper accepts a JSON configuration specifying search pages to scrape:

```json
{
  "urls": [
    "https://www.proxibid.com/for-sale/cars-vehicles/cars?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Links to ProxiBid search list pages (e.g., category pages, filtered searches). Paste one URL per entry or bulk edit. Examples: cars, real estate, collectibles category pages. |
| `max_items_per_url` | Integer | Maximum number of lots extracted per URL (default: `20`; typical range: 50–200). Increase for bulk collection; lower for quick samples. |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues even if individual URLs fail. Recommended for large-scale runs to prevent interruption. |

> **Tip:** Use filtered search URLs (e.g., by condition, price range, location) to target specific lot types and reduce data size.

***

### Output Format

#### Sample Output Record

```json
{
  "auction_ended": false,
  "auction_house_id": 794,
  "auction_house_name": "Kiko Auctioneers",
  "auction_type": "TIMED",
  "id": "101111527",
  "image_url": "https://images.proxibid.com/AuctionImages/794/296983/CatalogDetail/21-1.jpg",
  "location": "Akron, OH",
  "lot_details_url": "/cars-vehicles/cars/Ford-Model-A-Parts/lotInformation/101111527",
  "lot_id": 101111527,
  "lot_time_info": "12h 10m Left",
  "price": "$1.50",
  "title": "Ford Model A Parts",
  "from_url": "https://www.proxibid.com/for-sale/cars-vehicles/cars"
}
```

Each scraped lot returns the following 12 fields:

#### Lot Identification & Metadata

| Field | Meaning | Example Use |
|---|---|---|
| `Lot ID` | Unique identifier for the auction lot | Primary key for deduplication and tracking |
| `ID` | Alternate or internal lot reference | Database mapping or cross-referencing |
| `Title` | Item name and brief description | Product title shown on the listing |
| `Auction Type` | Category of sale (e.g., standard auction, sealed bid, live) | Understanding sale mechanics |

#### Pricing & Auction Status

| Field | Meaning | Example Use |
|---|---|---|
| `Price` | Current bid or hammer price | Market analysis, competitive pricing |
| `Auction Ended` | Timestamp or boolean indicating if auction is closed | Filtering active vs. historical lots |
| `Lot Time Info` | Remaining time, close time, or status message | Real-time auction tracking |

#### Auction House & Location

| Field | Meaning | Example Use |
|---|---|---|
| `Auction House ID` | Unique identifier for the seller/auctioneer | Seller analytics and reputation tracking |
| `Auction House Name` | Legal name of the auction company | Seller filtering and relationship mapping |
| `Location` | Geographic location (city, state, or region) | Shipping cost estimation, regional analysis |

#### Media & Navigation

| Field | Meaning | Example Use |
|---|---|---|
| `Image URL` | Direct link to the lot's primary photo | Content aggregation, thumbnail display |
| `Lot Details URL` | Full link to the lot's detail page on ProxiBid | Direct access to full listing; bid placement |

***

### Usage Instructions

1. **Find category or search pages** — Navigate ProxiBid (e.g., `cars-vehicles/cars`, `real-estate`, `collectibles`). Filter by condition, price, or location if desired.

2. **Copy the search URL** — Grab the full URL from your browser's address bar. Multiple URLs can be added in the `urls` array.

3. **Configure settings** — Set `max_items_per_url` to your target volume (e.g., `50` for small samples, `200` for comprehensive scrapes). Keep `ignore_url_failures: true` for reliability.

4. **Start the scraper** — Run the actor and monitor the progress. Logs show items collected and any failed URLs.

5. **Export & process** — Download results as JSON, CSV, or Excel. Use lot metadata to populate databases, dashboards, or BI tools.

**Best practices:**

- Scrape during off-peak hours to minimize rate limiting.
- Use narrower category URLs to reduce noise (e.g., `cars?condition=good` vs. all cars).
- Periodically refresh to track price changes and new listings.

***

### Use Cases & Business Value

- **Price benchmarking:** Track historical and current pricing for vehicles, real estate, or collectibles
- **Seller intelligence:** Identify top auctioneers, their inventory volumes, and pricing strategies
- **Market trend analysis:** Monitor demand shifts, seasonal patterns, and category saturation
- **Competitive monitoring:** Analyze competitor bidding behavior and reserve patterns
- **Inventory management:** Aggregate listings across multiple auctioneers for unified catalog

The **ProxiBid Lots Search Scraper** eliminates hours of manual data entry, enabling data-driven decision-making for resellers, logistics firms, and auction platform developers.

***

### Conclusion

The **ProxiBid Lots Search Scraper** is a powerful tool for anyone leveraging auction data at scale. Whether you're tracking vehicle prices, scouting real estate deals, or analyzing market trends, this scraper delivers complete lot records in seconds. Integrate auction data into your platform, automate competitive intelligence, and unlock new business opportunities.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the lots search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.proxibid.com/for-sale/cars-vehicles/cars?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.proxibid.com/for-sale/cars-vehicles/cars?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/proxibid-lots-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["https://www.proxibid.com/for-sale/cars-vehicles/cars?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/proxibid-lots-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.proxibid.com/for-sale/cars-vehicles/cars?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/proxibid-lots-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Proxibid Lots Search Scraper",
        "description": "Scrape auction listings from ProxiBid search pages effortlessly. This scraper collects titles, prices, auction house details, images, and lot metadata from cars, real estate, collectibles, and more — perfect for market researchers, resellers, and auction data analysts.",
        "version": "0.0",
        "x-build-id": "fe1eTkvcneghfUonv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~proxibid-lots-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-proxibid-lots-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~proxibid-lots-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-proxibid-lots-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~proxibid-lots-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-proxibid-lots-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the lots search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the lots search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
