# Auction.com Property Scraper (`crawlerbros/auction-com-scraper`) Actor

Scrape residential real estate auction listings from auction.com with bank-owned, foreclosure, and private-seller properties across all 50 US states.

- **URL**: https://apify.com/crawlerbros/auction-com-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Developer tools, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 10 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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.
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

## Auction.com Property Scraper

Scrape residential property listings from [Auction.com](https://www.auction.com) to extract detailed auction data, property information, and pricing. This scraper retrieves foreclosures, bank-owned properties, and live auctions from across the United States, ideal for real estate investors, market researchers, and financial analysts.

### What This Scraper Does

The Auction.com Property Scraper extracts comprehensive data from residential property listings, including property details (bedrooms, bathrooms, square footage), auction timelines, pricing information, and listing status. It supports filtering by location, property type, auction status, and sale type to help you build targeted datasets for market analysis, investment research, or portfolio monitoring.

### Input

Configure the scraper with the following fields:

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| **Start URLs** | `string[]` | One or more Auction.com search or listing URLs. Apply filters on the site (state, city, property type, sale type, bedrooms, etc.), then paste the URL here. Example: `https://www.auction.com/residential/?state=IL&city=Chicago` | `https://www.auction.com/residential/` |
| **Max Items** | `integer` | Maximum number of listings to scrape (1–10,000). | `50` |
| **Proxy Configuration** | `object` | Optional. The scraper uses Playwright's Chromium HTTP client which bypasses Incapsula bot protection automatically. A proxy is not needed for normal operation. | (none) |

#### How to Build a Start URL

1. Go to [auction.com/residential](https://www.auction.com/residential/)
2. Apply filters to narrow results:
   - Select a state or city
   - Choose property type (Single Family, Condo, etc.)
   - Filter by sale type (Foreclosure, Bank-Owned, etc.)
   - Set number of bedrooms, bathrooms, or price range
3. Copy the URL from your browser's address bar
4. Paste it into the **Start URLs** field above

You can provide multiple URLs to scrape different property segments in a single run.

### Output

The scraper returns detailed records for each property found, with the following fields:

#### Property Identification
| Field | Type | Description |
|-------|------|-------------|
| `id` | `string` | Auction.com internal listing ID |
| `urn` | `string` | Uniform Resource Name identifier |
| `url` | `string` | Canonical listing URL on Auction.com |

#### Listing Status
| Field | Type | Description |
|-------|------|-------------|
| `listingStatus` | `string` | Listing status code (e.g., `active`, `ended`) |
| `listingStatusGroup` | `string` | Grouped status category |
| `listingStatusLabel` | `string` | Human-readable status label |
| `isHot` | `boolean` | Whether the listing is marked as a "hot" property |

#### Location
| Field | Type | Description |
|-------|------|-------------|
| `address` | `string` | Property street address |
| `formattedAddress` | `string` | Full multi-line address joined into a single string (e.g. `"123 Main St, Chicago, IL 60601"`) |
| `city` | `string` | City name |
| `state` | `string` | U.S. state code (e.g., `IL`, `CA`, `TX`) |
| `county` | `string` | County name |
| `zipCode` | `string` | ZIP code |

#### Property Details
| Field | Type | Description |
|-------|------|-------------|
| `beds` | `integer` | Number of bedrooms |
| `baths` | `number` | Number of bathrooms (including half-baths) |
| `sqft` | `integer` | Interior square footage |
| `lotSqft` | `integer` | Lot size in square feet (converted from acres) |
| `yearBuilt` | `integer` | Year the property was constructed |
| `propertyType` | `string` | Property type code (e.g., `SFR` for Single Family, `CONDO`) |
| `propertyTypeGroup` | `string` | Grouped property type category |
| `latitude` | `number` | Geographic latitude coordinate |
| `longitude` | `number` | Geographic longitude coordinate |
| `propertyId` | `string` | Internal property identifier |

#### Pricing
| Field | Type | Description |
|-------|------|-------------|
| `openingBid` | `integer` | Starting bid amount in USD |
| `estimatedValue` | `integer` | Automated Valuation Model (AVM) estimated property value in USD |
| `sellerCurrentValue` | `integer` | Seller's valuation of the property in USD |
| `pricePerSqft` | `number` | Derived: `openingBid / sqft`, rounded to 2 decimal places (only when both values are present) |

#### Auction Details
| Field | Type | Description |
|-------|------|-------------|
| `auctionStartDate` | `string` | Auction start date/time (ISO 8601 format, UTC) |
| `auctionEndDate` | `string` | Auction end date/time (ISO 8601 format, UTC) |
| `visibleAuctionStartDate` | `string` | Date when auction becomes publicly visible (ISO 8601, UTC) |
| `isOnlineAuction` | `boolean` | Whether bidding is available online |
| `isRemoteBidEnabled` | `boolean` | Whether remote bidding is allowed |
| `showOpeningBid` | `boolean` | Whether the opening bid is publicly displayed |

#### Sale Configuration
| Field | Type | Description |
|-------|------|-------------|
| `saleType` | `string` | Sale type (e.g., `bank-owned`, `foreclosure`, `private-sale`) |
| `productType` | `string` | Product type classification |
| `occupancyStatus` | `string` | Occupancy status (e.g., `VACANT`, `OCCUPIED`) |
| `brokerCommission` | `number` | Broker commission rate (if applicable) |
| `buyerPremiumAvailable` | `boolean` | Whether buyer's premium applies |
| `financingAvailable` | `boolean` | Whether financing options are available |
| `interiorAccessAllowed` | `boolean` | Whether interior property viewing is permitted |
| `isFirstLookEnabled` | `boolean` | Whether First Look (early access) is enabled |
| `isDirectOfferEnabled` | `boolean` | Whether direct purchase offers are accepted |
| `isReserveDisplayed` | `boolean` | Whether reserve price is publicly shown |
| `isThirdPartyOnline` | `boolean` | Whether third-party online platform is available |

#### Media
| Field | Type | Description |
|-------|------|-------------|
| `photos` | `string[]` | Primary property photo URL(s) |
| `primaryPhotoUrl` | `string` | Convenience scalar of the primary photo URL (same as `photos[0]`) |
| `photoCount` | `integer` | Total number of photos available for this listing |

#### Metadata
| Field | Type | Description |
|-------|------|-------------|
| `scrapedAt` | `string` | Timestamp of data extraction (ISO 8601 format, UTC) |

### Error Records

When a URL fails to scrape, an error record is returned instead of a property record. Error records contain:

| Field | Type | Description |
|-------|------|-------------|
| `inputUrl` | `string` | The URL that failed to process |
| `error` | `string` | Error message describing the failure |
| `scrapedAt` | `string` | Timestamp of the error (ISO 8601 format, UTC) |

Error records help you identify and retry problematic URLs.

### Frequently Asked Questions

#### What properties are available on Auction.com?

Auction.com specializes in real estate auctions across the United States, including foreclosed properties, bank-owned homes, tax-delinquent properties, and court-ordered sales. Properties range from single-family homes to multi-unit residential buildings.

#### Do I need an Auction.com account to use this scraper?

No. The scraper does not require you to create or log in to an Auction.com account. It accesses public listing pages directly.

#### Which states and regions are covered?

Auction.com operates nationwide with properties in all 50 U.S. states. You can filter by state and city using the Start URL. Availability varies by region based on local market activity and auction schedules.

#### Can I filter by city, bedrooms, price range, or other criteria?

Yes. Apply filters directly on [Auction.com](https://www.auction.com/residential/) (state, city, property type, bedrooms, bathrooms, price range, auction status, etc.), then copy the filtered URL and paste it into the **Start URLs** field. The scraper will respect those filters.

#### Can I scrape a single property listing?

The scraper works best with search URLs. If you provide a detail page URL (e.g., `https://www.auction.com/details/123-main-st-chicago-il-1234567`), the scraper will automatically extract the state from the URL and return active listings for that state. For a specific listing, use a state-filtered search and identify the listing in the results.

#### What currency are prices displayed in?

All prices are in **United States Dollars (USD)**, including opening bid, estimated value, and seller's current value.

#### Can I run this scraper on a schedule?

Yes. When deployed to Apify, you can set up scheduled runs using Apify's [Actor Scheduling](https://docs.apify.com/platform/actors/running/scheduler) feature. This is useful for tracking new listings, monitoring price changes, or building a historical dataset over time.

#### Why are some output fields missing or null?

This scraper implements a strict "no-null contract" — fields are only included in the output when they contain genuine data. If a field is missing from the output, it means Auction.com did not provide that information for the property (e.g., no photos, no reserve price, no broker commission). This keeps your dataset clean and prevents confusion with missing vs. intentionally null values.

#### Do I need a proxy to use this scraper?

No. The scraper uses Playwright's Chromium HTTP client, whose TLS/HTTP fingerprint is recognised by Auction.com's bot protection as a real browser. Requests pass through without a proxy for most use cases.

If you encounter blocks in a specific region or network environment, you can optionally configure a proxy in the **Proxy Configuration** field.

#### What happens if the scraper encounters an error?

The scraper returns an error record with the failed URL, error message, and timestamp. Common causes include network timeouts or invalid input URLs. Check that:
- Your **Start URLs** are valid Auction.com search or listing URLs
- You have sufficient **Max Items** quota for the URLs you're scraping

#### How often is Auction.com data updated?

Auction.com continuously lists new properties and updates existing listings. Auction timelines, statuses, and availability change frequently. For real-time data, consider running the scraper on a schedule to capture the latest state.

#### Can I filter results by sale type or auction status?

Yes. The scraper respects filters applied on Auction.com, including:
- Sale type (foreclosure, bank-owned, tax sale, etc.)
- Auction status (active, ended, upcoming)
- Auction type (online, public, sealed bid)

Apply filters on the site, copy the URL, and paste it into the scraper's **Start URLs** field.

# Actor input Schema

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

One or more auction.com search or listing URLs. Apply filters on auction.com first (state, city, property type, sale type, bedrooms, etc.), then copy the URL and paste it here.
## `maxItems` (type: `integer`):

Maximum number of listings to scrape.
## `proxyConfiguration` (type: `object`):

Optional. The actor uses Playwright's Chromium HTTP client which bypasses Incapsula bot protection without a proxy. Add a proxy only if you encounter blocks.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.auction.com/residential/"
  ],
  "maxItems": 10
}
````

# 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 = {
    "startUrls": [
        "https://www.auction.com/residential/"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/auction-com-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 = {
    "startUrls": ["https://www.auction.com/residential/"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/auction-com-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 '{
  "startUrls": [
    "https://www.auction.com/residential/"
  ],
  "maxItems": 10
}' |
apify call crawlerbros/auction-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Auction.com Property Scraper",
        "description": "Scrape residential real estate auction listings from auction.com with bank-owned, foreclosure, and private-seller properties across all 50 US states.",
        "version": "0.0",
        "x-build-id": "yCrtMm3WfMFzP2Cnk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~auction-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-auction-com-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/crawlerbros~auction-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-auction-com-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/crawlerbros~auction-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-auction-com-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more auction.com search or listing URLs. Apply filters on auction.com first (state, city, property type, sale type, bedrooms, etc.), then copy the URL and paste it here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional. The actor uses Playwright's Chromium HTTP client which bypasses Incapsula bot protection without a proxy. Add a proxy only if you encounter blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
