# Auction.com Scraper - Foreclosures, Auctions & Property Data (`abotapi/auction-com-scraper`) Actor

From $1/1K. Extract foreclosure, REO, short-sale, and auction listings from Auction.com in minutes. Search by location and property filters or paste any Auction.com URL. Get 45+ structured fields, including auction dates, bids, estimated values, occupancy status, coordinates, and photos.

- **URL**: https://apify.com/abotapi/auction-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 24 total users, 12 monthly users, 88.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Auction.com Scraper: Foreclosure, Bank-Owned and Private-Seller Auction Listings

Auction.com Scraper turns Auction.com into structured real estate auction data. Search foreclosure, bank-owned, short-sale and private-seller listings by state, city, ZIP, property type, asset type, beds, baths, square footage, price and auction format, or paste one or more Auction.com search links straight from the site. Every listing comes back with dozens of structured fields including auction dates, starting bid, valuation estimates, occupancy and photos, and you can export to JSON, CSV or Excel, or pull results straight into your app through the API.

### Why This Scraper?

- **Two ways to build a search.** Filter by state, city, ZIP, property type, asset type, beds, baths, square footage, price and auction format, or paste one or more Auction.com search links and reuse work you already did on the site.
- **A wide field set per listing.** Address, coordinates, property facts, auction window, starting bid, valuation and rental estimates, occupancy, financing and buyer-premium flags, plus the complete source object under `raw` for anything not surfaced flat.
- **Optional full-detail pass.** Turn on `fetchDetails` for the complete photo gallery, financing preference, deposit and earnest-money minimums, leaseback terms and days-to-close per listing, billed only for listings that actually come back, not for every candidate checked. A pasted single-listing detail link always fetches full detail, regardless of this setting.
- **Resumable runs.** `resumeFromRunId` collects only the listings a previous run doesn't already have, so you can pick up where an earlier run left off without paying twice. Long runs also checkpoint their own progress, so a platform migration never restarts a run from zero.
- **Built for schedules.** Incremental mode remembers the previous run of the same search itself, so a recurring daily or weekly run returns only new and updated listings, and duplicates are suppressed and not billed.
- **One input controls volume.** `maxListings` is the sole cap on how many listings a run collects. Page walking itself has no artificial ceiling, so a capped run still sees the most relevant part of the catalogue first.
- **Multi-state and multi-URL in one run**, with automatic de-duplication across searches.

### Use Cases

- **Real estate investors:** filter foreclosure and bank-owned inventory by state, price range and property type to build a shortlist of deals.
- **Wholesalers and flippers:** run the same search on a schedule with incremental mode to catch new listings and price or status changes as soon as they post.
- **Market researchers and analysts:** build historical datasets of starting bids, valuation estimates and auction outcomes across states and asset types.
- **PropTech and lead-gen products:** feed structured auction listings into your own app, CRM or alerting tool through the API.
- **Due diligence teams:** pull full auction terms, financing preference and occupancy details for a shortlist of properties with `fetchDetails`.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| `listingId` | `"00000001"` |
| `url` | `"https://www.auction.com/details/123-sample-st-city-st-00000001"` |
| `address` | `"123 Sample St, Springfield, ST 00000"` |
| `city` / `state` / `zip` | `"Springfield"` / `"ST"` / `"00000"` |
| `county` | `"Sample County"` |
| `latitude` / `longitude` | `38.0000` / `-90.0000` |
| `propertyTypeGroup` | `"SINGLE_FAMILY"` |
| `assetType` | `"BANK_OWNED"` |
| `listingStatusGroup` | `"ACTIVE"` |
| `bedrooms` / `bathrooms` | `3` / `2` |
| `squareFootage` | `1800` |
| `lotSize` | `0.25` |
| `yearBuilt` | `1995` |
| `startingBid` | `150000` |
| `estimatedValue` | `225000` (valuation estimate) |
| `rentalEstimate` | `1800` (monthly rent estimate) |
| `auctionType` | `"ONLINE"` |
| `auctionStartDate` / `auctionEndDate` | `"2026-01-01T00:00:00Z"` / `"2026-01-03T00:00:00Z"` |
| `occupancyStatus` | `"VACANT"` |
| `financingAvailable` / `buyerPremiumAvailable` | `true` / `false` |
| `isRemoteBidEnabled` | `true` |
| `auctionDate` / `auctionStatus` | the site's auction day (a plain date, separate from the `auctionStartDate` start datetime above) and the auction status |
| `saleType` / `auctionLocation` | the auction event format reported by the site (`LIVE` or `ONLINE`; it can differ from `auctionType` on a few listings), and the venue address for in-person sales (empty for online) |
| `primaryPhoto` / `photoCount` | a photo URL / `12` |
| `raw` | the complete source listing object |

Every record also carries `isThirdPartyOnline`, `isDirectOfferEnabled`, `eventId`, `listingCode`, `listingCreatedDate`, `listingUpdatedDate`, `appraisalValue`, marketing tags, open house dates, trustee-sale and financing-broker flags, valuation bands (low/high) and an `isHot` marker, and the fields above cover only the flat, top-level view. When `fetchDetails` is on, each listing additionally gets a full photo array, financing preference, inspection and leaseback terms, days-to-close, earnest-money deposit minimum and the raw detail payload under `detailRaw`. When incremental mode is on, every returned record also carries `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt` (see "Resume and recurring updates" below).

#### Output views

The dataset has four tabs in the Console: **Overview** (address, city, state, ZIP, property and asset type, status, beds, baths, square footage, starting bid, estimated value, auction start date and type, listing URL, plus the incremental-change columns), **Auction & Bidding** (auction type, start and end dates, starting bid, online and remote-bid flags, occupancy, financing and buyer-premium availability), **Incremental Changes** (`changeType`, `changedFields`, first/last seen) and **Listing Terms (fetchDetails)** (seller terms intent, financing preference, financing and inspection contingencies, leaseback period and rent, days to close, private tours, earnest-money deposit minimum, program enrollment code). Fields are only added, none were renamed or removed.

### How to Use

1. Pick a **mode**: `search` (build a query from filters) or `url` (paste one or more Auction.com search links).
2. Fill in the filters for search mode (state, city, ZIP, property type, asset type, beds, baths, square footage, price), or paste your links for URL mode.
3. Turn on `fetchDetails` if you want full auction terms per listing, and set **Max listings** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search a single state for active listings:**

```json
{
  "mode": "search",
  "states": ["CA"],
  "listingStatus": "active",
  "maxListings": 200
}
```

**Filtered search across two states (condos and townhouses, 3+ beds, under 300k):**

```json
{
  "mode": "search",
  "states": ["TX", "FL"],
  "propertyTypes": ["condos-townhouses"],
  "minBeds": 3,
  "maxPrice": 300000,
  "sortBy": "price-asc",
  "maxListings": 500
}
```

**Bank-owned, online auctions, with full details:**

```json
{
  "mode": "search",
  "states": ["GA"],
  "assetTypes": ["bank-owned"],
  "auctionFormats": ["online"],
  "fetchDetails": true,
  "maxListings": 100
}
```

**Paste Auction.com links (apply filters on the website, then copy the link):**

```json
{
  "mode": "url",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt/single-family_pt",
    "https://www.auction.com/residential/TX/active_lt"
  ],
  "maxPages": 3
}
```

#### Supported link shapes (URL mode)

If you switch to URL mode and leave `urls` untouched, the actor now scrapes one example of each shape below (previously the field had no default). **Behaviour change:** previously `urls` had no default, so omitting it in URL mode scraped nothing; now it runs those example links. Always send your own `urls` (or `[]`) in URL mode.

| Shape | Example |
|---|---|
| State | `https://www.auction.com/residential/CA/active_lt` |
| Nationwide | `https://www.auction.com/residential/active_lt/` |
| City | `https://www.auction.com/residential/CA/Los-Angeles_ct/active_lt` |
| ZIP | `https://www.auction.com/residential/90210_zp/active_lt` |
| Paginated (starts at page N) | `https://www.auction.com/residential/CA/active_lt/2_cp` |
| Property / asset type | `https://www.auction.com/residential/CA/active_lt/single-family_pt/bank-owned_at` |
| Auction format | `https://www.auction.com/residential/CA/active_lt/online_af` |
| Beds / baths / sqft | `https://www.auction.com/residential/CA/active_lt/3_bd/2_bt/500_any_sqft` |
| Sorted | `https://www.auction.com/residential/CA/active_lt/auction_date_order,resi_sort_v2_st` |
| Without `www` | `https://auction.com/residential/TX/active_lt` |
| Sold listings | `https://www.auction.com/residential/CA/sold_lt` |

A `?page=2` link is accepted, but the site ignores it and serves page 1. The run logs a warning; use `/2_cp` instead.

Single-listing `/details/...` links are fetched by listing id. `/commercial/...` links are not supported and are skipped with a warning. A search that matches 0 listings logs a warning. In incremental mode a `/N_cp` link is a partial scan and never marks listings as expired.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/auction-com-scraper").call(run_input={"mode": "search", "states": ["CA"], "maxListings": 100})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["address"], listing["startingBid"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/auction-com-scraper').call({ mode: 'search', states: ['CA'], maxListings: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Max pages and Max listings

`maxPages` bounds how many result pages (100 listings per page) a search walks. Left at its default of `0`, it walks the whole catalogue: the run stops on its own once the site's own reported total is reached, a page comes back empty, or a page returns no listing that wasn't already collected. There is no artificial page-number ceiling. `maxListings` (default `20`) is the only cap on how many listings a run actually collects; set it to `0` for no limit. The two are independent: a small `maxPages` can still stop a run before `maxListings` is reached, and vice versa.

#### Resume and recurring updates

There are two different things here, and they solve different problems.

**Resume** (`resumeFromRunId`) continues one specific earlier run: paste its run id or dataset id and this run skips every listing already collected there, returning only the remaining new listings. Combine both datasets afterward for the full set. A separate, automatic checkpoint also protects long unlimited runs against a platform migration, resuming the same run from where it stopped without any input needed.

**Incremental mode** (`incrementalMode`) is for running the exact same search again and again, for example daily from the **Schedules** tab. The actor remembers the previous run of that search itself, keyed by a hash of your filters (or by `stateKey` if you set one), so you never paste a run id. The first run returns everything as `NEW`. Every later run returns `NEW` listings, and `UPDATED` listings with `changedFields` naming what changed (price, status, auction date, occupancy, and so on). Listings that are unchanged are suppressed and not billed unless you turn on `emitUnchanged`. A listing counts as changed when any returned field differs from the copy stored on the previous run. Never counted (still returned in the output): `scrapedAt`, the verbatim `raw` and `detailRaw` payloads, `primaryPhoto` (its CDN host rotates), `photosDetailed[].updatedDate`, and the order of `marketingTags` and `openHouses`. Use **Ignore fields when detecting changes (incremental mode only)** (`ignoreFieldsForChanges`) to exclude more fields, with dots for nested ones (for example `photosDetailed.updatedDate`); editing that list never produces a wave of `UPDATED` rows.

`REAPPEARED` and `EXPIRED` are a separate pair, and neither shows up under default settings. `EXPIRED` is only produced when `emitExpired` is on **and** the run fully scans the tracked search: not capped by Max listings or Max pages, not a Resume run, and not interrupted by a platform checkpoint. A listing only becomes eligible to reappear after it has actually been marked `EXPIRED` this way; if you never turn on `emitExpired`, a listing that temporarily disappears and comes back later is simply classified as `UNCHANGED` or `UPDATED` next time, never `REAPPEARED`. Turn on `emitExpired` deliberately if you want that history tracked, and be aware it also returns (and bills) the extra tombstone rows.

Using `resumeFromRunId` together with `incrementalMode` for a search that already has saved incremental state stops the run with an error, since the two features would otherwise double-count the same listings; remove one of them or pick a different `stateKey` to start a separate campaign.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each listing, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (use filters) or `url` (paste links). |
| `states` | array | none (prefill: `["CA"]`) | Two-letter US state codes. Leave empty to search nationwide. |
| `city` | string | (none) | Optional city name to narrow the search. |
| `zipCodes` | array | (none) | Optional 5-digit ZIP codes. |
| `keyword` | string | (none) | Free-text search across street, city, state and ZIP. |
| `listingStatus` | string | `active` | `active` (open for bidding) or `sold` (closed). |
| `propertyTypes` | array | (none, all types) | `single-family`, `condos-townhouses`, `multi-family`, `land`. |
| `assetTypes` | array | (none, all types) | `bank-owned`, `foreclosures`, `short-sales`, `private-seller`. |
| `auctionFormats` | array | (none, all formats) | `online`, `in-person`, `remote-bid`. |
| `minBeds` | integer | (none) | Minimum bedrooms. |
| `maxBeds` | integer | (none) | Maximum bedrooms. |
| `minBaths` | integer | (none) | Minimum bathrooms. |
| `minSqft` | integer | (none) | Minimum living area in square feet. |
| `maxSqft` | integer | (none) | Maximum living area in square feet. |
| `minPrice` | integer | (none) | Minimum starting bid in USD. |
| `maxPrice` | integer | (none) | Maximum starting bid in USD. |
| `sortBy` | string | `default` | Result ordering. |
| `urls` | array | one example link per supported shape (see below) | Auction.com search links (URL mode). |
| `fetchDetails` | boolean | `false` | Fetch the full photo gallery and auction terms per listing. |
| `maxPages` | integer | `0` | Bound on result pages walked per search/link (100 listings per page). `0` walks the whole catalogue and stops on its own; does not cap listing count. |
| `maxListings` | integer | `20` | The sole cap on total listings collected (max `1,000,000`). `0` means unlimited. |
| `resumeFromRunId` | string | (none) | ID of a previous run (or dataset) of this actor. Listings already there are skipped. |
| `incrementalMode` | boolean | `false` | Turn on for recurring monitoring of the same search. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only. Fields (dotted paths for nested ones) that never count as a change; still returned in the output. |
| `stateKey` | string | (none) | Optional name for a monitoring campaign, or to share state across runs. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) listings unchanged since the last run. |
| `emitExpired` | boolean | `false` | Also return (and bill) listings no longer found, once a run fully scans the tracked search. |
| `proxy` | object | Apify datacenter proxy | Connection settings. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each listing to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which items are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "listingId": "00000001",
  "url": "https://www.auction.com/details/123-sample-st-springfield-st-00000001",
  "address": "123 Sample St, Springfield, ST 00000",
  "city": "Springfield",
  "state": "ST",
  "zip": "00000",
  "county": "Sample County",
  "latitude": 38.0,
  "longitude": -90.0,
  "propertyTypeGroup": "SINGLE_FAMILY",
  "assetType": "BANK_OWNED",
  "occupancyStatus": "VACANT",
  "listingStatusGroup": "ACTIVE",
  "isHot": false,
  "bedrooms": 3,
  "bathrooms": 2,
  "squareFootage": 1800,
  "lotSize": 0.25,
  "yearBuilt": 1995,
  "startingBid": 150000,
  "estimatedValue": 225000,
  "estimatedValueLow": 210000,
  "estimatedValueHigh": 240000,
  "auctionType": "ONLINE",
  "auctionStartDate": "2026-01-01T00:00:00Z",
  "auctionEndDate": "2026-01-03T00:00:00Z",
  "financingAvailable": true,
  "buyerPremiumAvailable": false,
  "isRemoteBidEnabled": true,
  "primaryPhoto": "https://example.com/sample-property-photo.jpg",
  "photoCount": 12,
  "marketingTags": [],
  "openHouses": [],
  "scrapedAt": "2026-01-01T00:00:00Z"
}
```

### Plan Requirement

This scraper works on the default Apify datacenter proxy connection (measured: Auction.com search pages and its listing data service load through datacenter addresses; a plain home connection with no proxy is blocked), so no residential proxy is required. A paid Apify plan gives the most reliable runs, but a free plan is not a dead end. Apify free plans do not include any Apify Proxy, so the Apify connections are refused for the account; the run does not stop. It logs this notice: "The selected connection is unavailable to this run. Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable. For residential access, upgrade at https://apify.com/pricing or supply your own proxy URLs." and carries on over a backup connection (the log then says "Served over the backup connection (the default connection was unavailable)."), so listings are still returned, though some pages may fail more often than on a paid plan. The run ends with "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required: https://apify.com/pricing. If you entered your own proxy URLs, check that their credentials are valid." only when every connection, the backup included, is refused (for example when your own proxy URLs are all rejected). If you pick the residential group on a plan without it, you get the same notice and the same backup connection; if the backup cannot load pages either, the run ends with "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested Auction.com pages. Upgrade at https://apify.com/pricing or supply your own proxy URLs, then try again." If requests fail for any other reason and no results page ever loads, the status reads "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later." The residential group gives more headroom for large or frequent runs. Turning on `fetchDetails` adds one extra request per listing, billed only for listings that are actually returned, never for a candidate that gets checked and then suppressed. A pasted single-listing detail link always fetches and bills this extra request, whatever `fetchDetails` is set to.

### FAQ

#### How much does it cost?

You pay per listing returned, and the detail-enrichment charge is billed only for listings that actually come back in the dataset with detail fetched: search-mode or listing-URL results when **Fetch listing details** is on, and a pasted single-listing detail link always, since that always fetches full detail regardless of that setting. The **Pricing** tab shows the current rates. Use **Max listings** to cap the cost of any run.

#### Is it legal to scrape Auction.com?

This actor collects only publicly available auction listing data. You are responsible for how you use it: follow Auction.com's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Listing facts such as price, dates and property details are generally factual, but photos may be subject to third-party rights.

#### Can I get only new or changed listings on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Every run after the first then returns only new and updated listings, and unchanged ones are suppressed and not billed. See "Resume and recurring updates" above for exactly when `REAPPEARED` and `EXPIRED` show up, since both need `emitExpired` turned on ahead of time.

#### What's the difference between Resume and Incremental mode?

**Resume** (`resumeFromRunId`) continues one specific earlier run and is a one-time delta. **Incremental mode** is for running the same search over and over, for example daily, and tracks its own state without you ever pasting a run id. Using both together on a search that already has saved incremental state is rejected, since it would double-count listings.

#### Why did my run fail instead of returning an empty dataset?

A run only stops with an error when `resumeFromRunId` points at an id this account cannot read, or when it is combined with **Incremental mode** on a search that already has saved state. Everything else, including a search that matches no listings or an upstream request that could not be completed, finishes as a normal run; if nothing was returned, the status message says why, and the run log shows any page that could not be loaded. Try again if it points at a temporary connection issue.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push a summary of each listing into Notion, Linear or Airtable.

### 🔗 Want more real estate data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🧩 <a href="https://apify.com/abotapi/propwire-property-leads-scraper"><b>Propwire Scraper</b></a><br>Scrape Propwire.com: 157M+ US MLS &amp; off-market properties with owner names, mailing...</td><td>🧩 <a href="https://apify.com/abotapi/homes-com-scraper"><b>Homes.com Scraper</b></a><br>Scrape US property records from Homes.com. Pick a city, state or ZIP and a channel (for...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/redfin-scraper"><b>Redfin Scraper</b></a><br>Scrape redfin.com home listings: price, beds, baths, sqft, lot, year built, coordinates...</td><td>🏠 <a href="https://apify.com/abotapi/realestate-co-nz-scraper"><b>RealestateCo NZ</b></a><br>From $1/1K. Search and extract all real estate properties for sale, rent, and sold across...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/boe-es-auction-scraper"><b>Spain Property &amp; Judicial Auctions Scraper</b></a><br>Scrape Spain's official BOE auction portal: judicial and public auction listings with...</td><td>🏠 <a href="https://apify.com/abotapi/rumah123-indonesia-property-scraper"><b>Rumah123 Scraper</b></a><br>Pull structured property listings from Rumah123.com, Indonesia’s largest property portal...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/auction-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

How to find listings. 'search' builds the query from the filter fields below. 'url' takes one or more Auction.com search URLs you paste.

## `states` (type: `array`):

Two-letter US state codes to search, e.g. CA, TX, FL. Leave empty to search nationwide.

## `city` (type: `string`):

Optional city name to narrow the search, e.g. Los Angeles. Combine with a single state for best results.

## `zipCodes` (type: `array`):

Optional list of 5-digit ZIP codes to narrow the search.

## `keyword` (type: `string`):

Optional free-text search across street, city, state and ZIP, e.g. 'Main St' or '90210'.

## `listingStatus` (type: `string`):

Active listings open for bidding, or sold/closed listings.

## `propertyTypes` (type: `array`):

Filter by property category. Leave empty for all.

## `assetTypes` (type: `array`):

Filter by distressed-asset category. Leave empty for all.

## `auctionFormats` (type: `array`):

Filter by how the auction is run. Leave empty for all.

## `minBeds` (type: `integer`):

Minimum number of bedrooms.

## `maxBeds` (type: `integer`):

Maximum number of bedrooms.

## `minBaths` (type: `integer`):

Minimum number of bathrooms.

## `minSqft` (type: `integer`):

Minimum living area in square feet.

## `maxSqft` (type: `integer`):

Maximum living area in square feet.

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

Minimum starting bid in USD.

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

Maximum starting bid in USD.

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

Result ordering.

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

One or more Auction.com search URLs (state, nationwide, city, ZIP, paginated /N_cp, filtered, sorted). Apply filters on the website, copy the URL, and paste it here. Leave untouched to scrape one example of each supported link shape. Commercial links are not supported. Search-mode filter fields above are ignored.

## `fetchDetails` (type: `boolean`):

Make an extra request per listing for the full photo gallery, complete auction terms, deposit/financing details and documents. Slower and billed per detail page; off by default.

## `maxPages` (type: `integer`):

Optional bound on result pages walked per search/URL (100 listings per page). Use 0 to walk the whole catalogue: the run stops on its own once the site's reported total is reached, a page comes back empty, or a page returns no new listings. This does NOT cap the number of listings; use Max listings for that.

## `maxListings` (type: `integer`):

Hard cap on total listings collected. 0 means unlimited (paid plans).

## `proxy` (type: `object`):

Proxy configuration. Apify datacenter (the default) works well for this source; no residential proxy required.

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Listings already in that dataset are skipped, so this run returns only NEW listings (a delta). Combine both runs' datasets for the full set. Max listings then counts only the new listings. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching listings as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED listings. UPDATED is decided by comparing every returned listing field (bid, status, auction dates, address, occupancy, valuation, tags, open houses, photo count and so on) with the stored copy from the previous run; changedFields names the fields that differ. Excluded from the comparison (still returned in the output): scrapedAt, the verbatim raw/detailRaw payloads, the primary photo URL (its CDN host rotates), photo update timestamps, and the order of marketing tags and open houses; plus anything you list in "Ignore fields" below. Turn on "Emit unchanged" or "Emit expired" only when you also want those listings returned (and billed). State is kept separately for each distinct search/filter setup (or by State key below).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from your search/filter settings — different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return listings that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return listings that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search — not when Max listings or Max pages capped it, or when Resume was used. This returns — and bills — extra synthetic rows.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Field names that must NOT count as a change in incremental mode: they are left out of the comparison and out of changedFields, but are still returned in every record. Nested fields use dots, e.g. photosDetailed.updatedDate (lists are searched automatically). Changing this list never causes a wave of UPDATED rows.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "states": [
    "CA"
  ],
  "listingStatus": "active",
  "sortBy": "default",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt",
    "https://www.auction.com/residential/active_lt/",
    "https://www.auction.com/residential/CA/Los-Angeles_ct/active_lt",
    "https://www.auction.com/residential/90210_zp/active_lt",
    "https://www.auction.com/residential/CA/active_lt/2_cp",
    "https://www.auction.com/residential/CA/active_lt/single-family_pt/bank-owned_at",
    "https://www.auction.com/residential/CA/active_lt/online_af",
    "https://www.auction.com/residential/CA/active_lt/3_bd/2_bt/500_any_sqft",
    "https://www.auction.com/residential/CA/active_lt/auction_date_order,resi_sort_v2_st",
    "https://auction.com/residential/TX/active_lt",
    "https://www.auction.com/residential/CA/sold_lt"
  ],
  "fetchDetails": false,
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `auction` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `detail` (type: `string`):

No description

# 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 = {
    "mode": "search",
    "states": [
        "CA"
    ],
    "listingStatus": "active",
    "sortBy": "default",
    "urls": [
        "https://www.auction.com/residential/CA/active_lt",
        "https://www.auction.com/residential/active_lt/",
        "https://www.auction.com/residential/CA/Los-Angeles_ct/active_lt",
        "https://www.auction.com/residential/90210_zp/active_lt",
        "https://www.auction.com/residential/CA/active_lt/2_cp",
        "https://www.auction.com/residential/CA/active_lt/single-family_pt/bank-owned_at",
        "https://www.auction.com/residential/CA/active_lt/online_af",
        "https://www.auction.com/residential/CA/active_lt/3_bd/2_bt/500_any_sqft",
        "https://www.auction.com/residential/CA/active_lt/auction_date_order,resi_sort_v2_st",
        "https://auction.com/residential/TX/active_lt",
        "https://www.auction.com/residential/CA/sold_lt"
    ],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": true
    },
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "mode": "search",
    "states": ["CA"],
    "listingStatus": "active",
    "sortBy": "default",
    "urls": [
        "https://www.auction.com/residential/CA/active_lt",
        "https://www.auction.com/residential/active_lt/",
        "https://www.auction.com/residential/CA/Los-Angeles_ct/active_lt",
        "https://www.auction.com/residential/90210_zp/active_lt",
        "https://www.auction.com/residential/CA/active_lt/2_cp",
        "https://www.auction.com/residential/CA/active_lt/single-family_pt/bank-owned_at",
        "https://www.auction.com/residential/CA/active_lt/online_af",
        "https://www.auction.com/residential/CA/active_lt/3_bd/2_bt/500_any_sqft",
        "https://www.auction.com/residential/CA/active_lt/auction_date_order,resi_sort_v2_st",
        "https://auction.com/residential/TX/active_lt",
        "https://www.auction.com/residential/CA/sold_lt",
    ],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": { "useApifyProxy": True },
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/auction-com-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 '{
  "mode": "search",
  "states": [
    "CA"
  ],
  "listingStatus": "active",
  "sortBy": "default",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt",
    "https://www.auction.com/residential/active_lt/",
    "https://www.auction.com/residential/CA/Los-Angeles_ct/active_lt",
    "https://www.auction.com/residential/90210_zp/active_lt",
    "https://www.auction.com/residential/CA/active_lt/2_cp",
    "https://www.auction.com/residential/CA/active_lt/single-family_pt/bank-owned_at",
    "https://www.auction.com/residential/CA/active_lt/online_af",
    "https://www.auction.com/residential/CA/active_lt/3_bd/2_bt/500_any_sqft",
    "https://www.auction.com/residential/CA/active_lt/auction_date_order,resi_sort_v2_st",
    "https://auction.com/residential/TX/active_lt",
    "https://www.auction.com/residential/CA/sold_lt"
  ],
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/auction-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/auction-com-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/GF5lScACE4b4uNnsP/builds/vvwwO7qmbCjAZwRQc/openapi.json