# Auction.com \[Only 💰$1 ] Search and Details Scraper (`memo23/auction-com-scraper`) Actor

\[💰$1 per 1,000] No limits, no quotas, unlimited extraction. Auction.com scraper that extracts structured property listings from search URLs and filters. Get listing URLs, photos, address data, beds, baths, sqft, lot size, year built, bids, sale type, auction dates, occupancy, and property status

- **URL**: https://apify.com/memo23/auction-com-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 133 total users, 21 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

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

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

**Unlock the Full Power of Auction.com Property Data** - Track, analyze, and monitor Auction.com listings with a scraper built for search result pages, URL-based filters, and structured real-estate output. Whether you are following bank-owned inventory, foreclosure activity, nearby search results, or pricing and occupancy trends, this actor turns Auction.com listing data into a usable dataset for research, lead generation, and market analysis.

*"From active online auctions to filtered foreclosure and bank-owned inventory, we turn Auction.com's listing data into your competitive advantage."*

### Overview

The Auction.com Scraper extracts structured property listing data from Auction.com URLs. It supports search result URLs, direct property detail URLs, and searches built from filters you set in the input (state, city, category, listing type, sale format). Paste a search URL and you get the listings that search shows on Auction.com, with its location, sale-format and sort filters applied, up to your `maxItems` limit. Each property comes back as one flattened record, ready for export to JSON or CSV.

### What does Auction.com Scraper do?

The Auction.com Scraper is a powerful tool that enables you to:

#### Comprehensive Data Collection

- **Property Listings**
  - Extract listing IDs, listing URLs, address data, photos, auction dates, and sale type
  - Capture property characteristics such as beds, baths, square footage, lot size, and year built
  - Gather auction signals like opening bid, starting bid, online vs live auction, and reserve visibility
  - Track listing features such as buyer premium availability, occupancy status, financing availability, broker coop, and first look flags
  - Collect property value fields such as estimated resale value when available
- **Search Context**
  - Keep every filter you set in the Auction.com search URL
  - Preserve listing state across online auction, foreclosure, bank-owned, and coming soon inventory
  - Support real-estate filter dimensions such as property type, occupancy, beds, baths, sqft, price, sale format, and market-insight tags

#### Advanced Scraping Capabilities

- **Search URL support**: Paste any Auction.com search URL and get the same results the site shows for it
- **Pagination Handling**: Automatically follows additional result pages until the search is complete
- **Efficient Processing**: Processes only new or unseen listings in monitoring mode
- **Flexible Filtering**: Supports hardcoded mapping for many Auction.com filter suffixes used in real search URLs
- **Structured Output**: Returns flattened, competitor-style listing records for easy downstream use

#### Flexible Scraping Options

- **Search Results**: Scrape all property listings from an Auction.com search URL
  - Example: `https://www.auction.com/residential/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af`
- **ZIP-Code Search**: Scrape listings inside a single ZIP (and nearby properties when `nearby_search` is on)
  - Example: `https://www.auction.com/residential/07605_zp/`
- **State or County Search**: Scrape using a 2-letter state code or `*_co` county slug as the only geo scope
  - State example: `https://www.auction.com/residential/NJ/`
  - County example: `https://www.auction.com/residential/CA/Los-Angeles_co/`
- **Filtered Searches**: Apply Auction.com path filters directly in the start URL
  - Example: `https://www.auction.com/residential/IL/Chicago_ct/active_lt/offer,direct_offer,remote_bid,in_person,online_af/auction_date_order,resi_sort_v2_st/y_fa/y_nbs/100_nsr`
- **Direct Property Details**: Scrape a single Auction.com property detail URL directly
  - Example: `https://www.auction.com/details/638-e-91st-st-chicago-il-2037268`
- **Built Search URLs**: Build one search URL from state, city, listing type, and sale format inputs when `startUrls` is empty

#### Supported URL Geo Scopes

The parser identifies path segments by suffix, so any combination of geo scope + filter segments works as long as at least one geo scope is present:

| Segment pattern | Meaning | Example |
|---|---|---|
| `XX` (2 uppercase letters) | State | `NJ`, `IL` |
| `*_ct` | City | `Chicago_ct` |
| `*_co` | County | `Los-Angeles_co` |
| `*_zp` | ZIP code | `07605_zp` |
| `*_lt` | Listing type | `active_lt` |
| `*_af` | Sale formats | `online,in_person_af` |

For ZIP-based URLs the actor automatically resolves a `geo_location` (lat/lon) for the ZIP centroid so `nearby_search` returns properties around the ZIP. You can override this by appending `?geo_location=lat,lon` to the start URL.

This tool is ideal for:

- Auction inventory research and monitoring
- Tracking bank-owned and foreclosure property trends
- Building structured property datasets for analysis or resale
- Monitoring new or changed inventory over time
- Supporting lead generation, acquisitions, and market intelligence workflows

### Features

- **Comprehensive Data Extraction**: Detailed property listing, auction, and search-filter data
- **Collection**:
  - **Search Results**: Scrape all listings from Auction.com search results (e.g., `https://www.auction.com/residential/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af`)
  - **ZIP / State / County Search**: Use a 2-letter state code, a `*_co` county slug, or a `*_zp` ZIP code as the geo scope (e.g., `https://www.auction.com/residential/07605_zp/`)
  - **Direct Detail URLs**: Scrape an individual property from a detail page URL (e.g., `https://www.auction.com/details/638-e-91st-st-chicago-il-2037268`)
  - **Flattened Output**: Return one normalized record per property
- **Flexible Input**: Supports multiple input formats:
  - Search result URLs copied directly from Auction.com
  - Direct property detail URLs copied from Auction.com
  - Built search URLs from Auction.com path inputs
  - Advanced Auction.com filter URLs with many supported path suffixes
- **Automatic Pagination**: Handles multi-page result sets automatically
- **Efficient Processing**: Concurrent scraping with configurable concurrency settings
- **Reliable Performance**: Built-in retry mechanisms and proxy support
- **Structured Data Export**: Download property listing data in JSON or CSV format for analysis

### How to Use

#### Scraping Property Listings

To scrape Auction.com property listings:

1. **Set Up**: Ensure you have an Apify account and access to the Apify platform.
2. **Configure Input**: Provide one or more Auction.com search URLs, direct property detail URLs, or build one search URL using state/city inputs:
   - `https://www.auction.com/residential/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af`
   - `https://www.auction.com/residential/IL/Chicago_ct/active_lt/offer,direct_offer,remote_bid,in_person,online_af/auction_date_order,resi_sort_v2_st/y_fa/y_nbs/100_nsr`
   - `https://www.auction.com/residential/07605_zp/` (ZIP-only search)
   - `https://www.auction.com/residential/NJ/` (state-only search)
   - `https://www.auction.com/residential/CA/Los-Angeles_co/` (county search)
   - `https://www.auction.com/details/638-e-91st-st-chicago-il-2037268`
3. **Adjust Settings**: Configure options like max items, monitoring mode, and proxy settings as needed.
4. **Run the Scraper**: Execute the scraper on the Apify platform.
5. **Data Collection**: The scraper will output flattened Auction.com property records.

### Input Configuration

Here's an example of how to set up the input for the Auction.com Scraper:

```json
{
    "startUrls": [
        "https://www.auction.com/residential/IL/Chicago_ct/active_lt/offer,direct_offer,remote_bid,in_person,online_af/auction_date_order,resi_sort_v2_st/y_fa/y_nbs/100_nsr",
        "https://www.auction.com/residential/07605_zp/",
        "https://www.auction.com/details/638-e-91st-st-chicago-il-2037268"
    ],
    "searchLimit": 500,
    "sort": "auction_date_order,resi_sort_v2",
    "nearbySearch": true,
    "nearbySearchRadius": 50,
    "requiresAggregation": true,
    "maxItems": 1000,
    "monitoringMode": false,
    "maxConcurrency": 5,
    "minConcurrency": 1,
    "maxRequestRetries": 5,
    "proxy": {
        "useApifyProxy": true
    }
}
```

#### Input Fields Explanation

- `startUrls`: Array of Auction.com URLs. Supported values include search URLs (city, ZIP, county, or state-scoped — see [Supported URL Geo Scopes](#supported-url-geo-scopes)) and direct property detail URLs. If provided, these URLs are used as-is.
- `propertyCategory`: Category used when building a search URL internally (for example, `residential`).
- `propertyState`: State code used when building a search URL (for example, `IL`).
- `propertyCity`: City used when building a search URL (for example, `Chicago`).
- `listingType`: Listing type used when building a search URL (for example, `active`).
- `assetEventTypes`: Sale format values used when building a search URL.
- `searchLimit`: Number of records requested per search page.
- `sort`: Sort order for the search results.
- `nearbySearch`: Whether to include properties near the searched area.
- `nearbySearchRadius`: Default nearby-search radius when the URL does not override it.
- `requiresAggregation`: Whether to request the aggregation block in the search response.
- `maxItems`: Maximum number of listings to emit.
- `monitoringMode`: When enabled, only emits listings not seen in previous runs.
- `maxConcurrency`: Maximum number of requests processed simultaneously.
- `minConcurrency`: Minimum number of requests processed simultaneously.
- `maxRequestRetries`: Number of retries for failed requests.
- `proxy`: Proxy settings for enhanced scraping reliability.

### Monitoring Mode

When `monitoringMode` is enabled, the scraper will only collect new listings that haven't been seen in previous runs. This is useful for:

- Tracking newly published or newly discovered property listings
- Building a historical archive of Auction.com inventory
- Monitoring cities or filter combinations without duplicating already-seen listings

#### How Monitoring Mode Works

1. The scraper maintains a record of previously scraped Auction.com listing IDs
2. On subsequent runs with `monitoringMode: true`, it checks each listing against this record
3. Only unseen listings are processed and added to the output
4. The record is updated with any new listing IDs found

### Output Structure

The scraper provides flattened Auction.com property listing records. The output includes listing identity, property attributes, auction timing, sale metadata, and useful booleans for filtering and analysis.

#### Sample JSON Output

```json
{
  "address": "638 E 91ST ST, CHICAGO, IL 60619, COOK COUNTY",
  "street_description": "638 E 91ST ST",
  "postal_code": "60619",
  "municipality": "CHICAGO",
  "country_secondary_subdivision": "COOK",
  "country_primary_subdivision": "IL",
  "saleType": "Bank Owned",
  "status": "Apr 14 - Apr 16, 2026",
  "auctionLocation": "Online Auction",
  "auctionDate": "2026-04-14",
  "auctionTime": "12:00",
  "auction_start_date": "2026-04-14T12:00:00Z",
  "auction_end_date": "2026-04-16T14:10:30Z",
  "opening_bid": 35000,
  "starting_bid_amount": 35000,
  "est_resale_value": null,
  "property_type": "SINGLE_FAMILY_HOME",
  "property_type_group": "SINGLE_FAMILY",
  "occupancy_status": "OCCUPIED",
  "interior_access_allowed": false,
  "beds": 2,
  "baths": 1,
  "sqft": 846,
  "lot_sqft": 0.07,
  "year_built": 1922,
  "financing_available": null,
  "buyer_premium_available": false,
  "broker_commission": null,
  "is_reserve_displayed": null,
  "is_third_party_online": null,
  "is_first_look_enabled": false,
  "is_direct_offer_enabled": false,
  "listing_photos_count": 5,
  "primary_photo_url": "https://adc-tenbox-prod.imgix.net/resi/propertyImages/755499/755499_ext_1.v1.jpeg?auto=compress,format",
  "url": "https://www.auction.com/details/638-e-91st-st-chicago-il-2037268",
  "id": "2037268",
  "scrapedTimestamp": "2026-04-14T21:35:29.932Z"
}
```

### Output Fields Explanation

This section provides a detailed breakdown of all fields in the JSON output from the Auction.com Scraper. The output is a single flattened record per listing.

#### Location

- `address` (String): Combined one-line address including street, city, state, postal code, and county when available.
- `street_description` (String): Street line of the property address in uppercase.
- `postal_code` (String): ZIP/postal code for the property.
- `municipality` (String): City/municipality in uppercase. Example: `"CHICAGO"`.
- `country_secondary_subdivision` (String): County name without the word `COUNTY`. Example: `"COOK"`.
- `country_primary_subdivision` (String): State or primary subdivision code. Example: `"IL"`.

#### Sale And Auction Timing

- `saleType` (String|null): Human-readable sale classification derived from Auction.com listing fields, for example `Bank Owned`, `Foreclosure`, or `Private Seller`.
- `status` (String|null): Auction.com status label shown in search results, for example `Apr 14 - Apr 16, 2026`, `Apr 28`, or `Coming Soon`.
- `auctionLocation` (String|null): Human-readable auction location, usually `Online Auction` or `Live Auction`.
- `auctionDate` (String|null): Date portion derived from `auction_start_date` in `YYYY-MM-DD` format.
- `auctionTime` (String|null): Time portion derived from `auction_start_date` in `HH:MM` format.
- `auction_start_date` (ISO 8601|null): Auction start timestamp in UTC.
- `auction_end_date` (ISO 8601|null): Auction end timestamp in UTC when available.

#### Pricing And Valuation

- `opening_bid` (Number|null): Opening bid value from the listing auction block.
- `starting_bid_amount` (Number|null): Starting bid amount, including online segment fallback when present.
- `est_resale_value` (Number|null): Estimated resale/composite valuation when available.

#### Property Attributes

- `property_type` (String|null): Detailed structure type code such as `SINGLE_FAMILY_HOME`, `DUPLEX_BUILDING`, or `MULTI_UNIT_BUILDING`.
- `property_type_group` (String|null): Broader structure grouping such as `SINGLE_FAMILY` or `MULTI_FAMILY`.
- `occupancy_status` (String|null): Occupancy state such as `OCCUPIED` or `VACANT`.
- `interior_access_allowed` (Boolean|null): Whether interior access is allowed.
- `beds` (Number|null): Number of bedrooms.
- `baths` (Number|null): Number of bathrooms. Can be an integer or decimal such as `1.5` or `2.5`.
- `sqft` (Number|null): Interior square footage.
- `lot_sqft` (Number|null): Lot size value as returned by Auction.com.
- `year_built` (Number|null): Year the property was built.

#### Listing Terms

- `financing_available` (Boolean|null): Whether financing is available for the property.
- `buyer_premium_available` (Boolean|null): Whether a buyer premium applies.
- `broker_commission` (Number|null): Broker commission amount or value when returned.
- `is_reserve_displayed` (Boolean|null): Whether reserve information is displayed.
- `is_third_party_online` (Boolean|null): Whether the listing is handled as a third-party online sale.
- `is_first_look_enabled` (Boolean|null): Whether first-look access is enabled.
- `is_direct_offer_enabled` (Boolean|null): Whether direct offers are enabled.

#### Photos, Links And Metadata

- `listing_photos_count` (Number|null): Number of photos available for the listing.
- `primary_photo_url` (String): Main listing photo URL.
- `url` (String): Full Auction.com detail page URL for the listing.
- `id` (String): Auction.com listing ID. Example: `"2037268"`.
- `scrapedTimestamp` (ISO 8601): Timestamp for when the actor produced the output row.

***

### Explore More Scrapers

If you found this Auction.com Scraper useful, be sure to check out our other scrapers and actors at [memo23's Apify profile](https://apify.com/memo23). We offer a wide range of tools to support web scraping, data collection, and automation across multiple sites and use cases.

### Support

- For issues or feature requests, please use the [Issues](https://console.apify.com/actors/7Fw4OYjfMapM6l49D/issues) section of this actor.
- If you need customization or have questions, feel free to contact the author:
  - Author's website: <https://muhamed-didovic.github.io/>
  - Email: <muhamed.didovic@gmail.com>

### Additional Services

- Request customization or whole dataset: <muhamed.didovic@gmail.com>
- If you need anything else scraped, or this actor customized, email: <muhamed.didovic@gmail.com>
- For API services of this scraper (no Apify fee, just usage fee for the API), contact: <muhamed.didovic@gmail.com>
- Email: muhamed.didovic@gmail.com

***

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/auction-com-scraper`).

**Purpose:** Scrapes Auction.com real-estate listings into one flattened record per property, from search URLs (state / city / county / ZIP scopes) or direct detail URLs.

**Minimal input:**

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

When `startUrls` is empty, the actor instead builds one search URL from the filter fields `propertyCategory` (`residential`), `propertyState` (`IL`), `propertyCity` (`Chicago`), `listingType` (`active`), and `assetEventTypes` (`["online","in_person","remote_bid","offer"]`).

**Output:** one row per listing — `id`, `url`, `primary_photo_url`, `address`, `country_primary_subdivision`, `country_secondary_subdivision`, `municipality`, `postal_code`, `street_description`, `beds`, `baths`, `sqft`, `lot_sqft`, `year_built`, `property_type`, `property_type_group`, `opening_bid`, `est_resale_value`, `starting_bid_amount`, `auction_start_date`, `auction_end_date`, `auctionDate`, `auctionTime`, `auctionLocation`, `status`, `saleType`, listing-configuration flags, `scrapedTimestamp`.

**Behaviors an agent should know:**

- `startUrls` take priority; the URL-building filter fields are used only when `startUrls` is empty.
- `maxItems` caps emitted listings (default 1000). Set it to control cost — a state-scoped run can return thousands of properties.
- `monitoringMode` emits only listings not seen in previous runs for the same user (keeps a record of seen listing IDs across runs).
- `startUrls` accept state, city, county, and ZIP search scopes plus direct `/details/…` property URLs.
- Pay-per-event billing — see the Pricing tab on the actor page.

***

### ⚠️ Disclaimer

This Actor is an independent tool. Auction.com, LLC and its subsidiaries did not make it, do not run it and have not approved it. Auction.com and other names mentioned here belong to their owners.

The scraper accesses only publicly available Auction.com listing pages — no authenticated endpoints, paid features, or content behind the Auction.com login wall. Users are responsible for ensuring their use complies with Auction.com's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

auction.com scraper, scrape auction.com, auction.com api, auction.com data extractor, real estate auction scraper, foreclosure listings scraper, bank owned properties scraper, reo property data, distressed property scraper, property auction data, real estate lead generation, foreclosure market analysis, investment property data, residential auction listings, real estate investor tools, Apify auction.com, us real estate data, property valuation data, auction date tracking, real estate market intelligence

# Actor input Schema

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

Full Auction.com search URLs copied from your browser. Supported geo scopes: state (`/residential/NJ/`), city (`/residential/IL/Chicago_ct/`), county (`/residential/CA/Los-Angeles_co/`), and ZIP code (`/residential/07605_zp/`). Filter suffixes such as `_lt`, `_af`, `_pt`, `_bd`, `_bt`, `_sqft`, `_price`, `_st`, `_sr`, `_nbp`, `_dsfp`, `_nbs`, `_bc`, `_fa`, `_nsr`, `_mt`, `_at` are supported. Direct property detail URLs (`https://www.auction.com/details/...`) are also accepted.

## `propertyCategory` (type: `string`):

Path segment before state, for example `residential`.

## `propertyState` (type: `string`):

Two-letter state code such as `IL`.

## `propertyCity` (type: `string`):

City name used in the search, for example `Chicago`.

## `listingType` (type: `string`):

Listing type slug before `_lt`, for example `active`.

## `assetEventTypes` (type: `array`):

Auction modalities used in the final path segment. `offer` is automatically converted to `offer_af` in the URL.

## `searchLimit` (type: `integer`):

Number of results requested per search page.

## `sort` (type: `string`):

Sort order for the search results.

## `nearbySearch` (type: `boolean`):

Whether to include properties near the searched area.

## `nearbySearchRadius` (type: `integer`):

Radius used when nearby search is enabled.

## `requiresAggregation` (type: `boolean`):

Include the search summary block (counts per filter) with the results.

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

Maximum number of listings that will be emitted.

## `monitoringMode` (type: `boolean`):

When enabled, only listings not seen in previous runs for the same user are emitted.

## `maxConcurrency` (type: `integer`):

Maximum number of requests processed at the same time.

## `minConcurrency` (type: `integer`):

Minimum number of requests processed at the same time.

## `maxRequestRetries` (type: `integer`):

Number of retries before a request is considered failed.

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

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.auction.com/residential/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af",
    "https://www.auction.com/residential/07605_zp/"
  ],
  "propertyCategory": "residential",
  "propertyState": "IL",
  "propertyCity": "Chicago",
  "listingType": "active",
  "assetEventTypes": [
    "online",
    "in_person",
    "remote_bid",
    "offer"
  ],
  "searchLimit": 500,
  "sort": "auction_date_order,resi_sort_v2",
  "nearbySearch": true,
  "nearbySearchRadius": 50,
  "requiresAggregation": true,
  "maxItems": 1000,
  "monitoringMode": false,
  "maxConcurrency": 5,
  "minConcurrency": 1,
  "maxRequestRetries": 5
}
```

# 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/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af",
        "https://www.auction.com/residential/07605_zp/"
    ],
    "propertyCategory": "residential",
    "propertyState": "IL",
    "propertyCity": "Chicago",
    "listingType": "active",
    "assetEventTypes": [
        "online",
        "in_person",
        "remote_bid",
        "offer"
    ],
    "sort": "auction_date_order,resi_sort_v2"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af",
        "https://www.auction.com/residential/07605_zp/",
    ],
    "propertyCategory": "residential",
    "propertyState": "IL",
    "propertyCity": "Chicago",
    "listingType": "active",
    "assetEventTypes": [
        "online",
        "in_person",
        "remote_bid",
        "offer",
    ],
    "sort": "auction_date_order,resi_sort_v2",
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "startUrls": [
    "https://www.auction.com/residential/IL/Chicago_ct/active_lt/online,in_person,remote_bid,offer_af",
    "https://www.auction.com/residential/07605_zp/"
  ],
  "propertyCategory": "residential",
  "propertyState": "IL",
  "propertyCity": "Chicago",
  "listingType": "active",
  "assetEventTypes": [
    "online",
    "in_person",
    "remote_bid",
    "offer"
  ],
  "sort": "auction_date_order,resi_sort_v2"
}' |
apify call memo23/auction-com-scraper --silent --output-dataset

```

## MCP server setup

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