# Auction.com Foreclosure Listings Scraper (`automation-lab/auction-com-foreclosure-listings-scraper`) Actor

🏠 Collect public Auction.com foreclosure, bank-owned, and private-seller auction listings with bids, dates, property facts, occupancy, coordinates, and photos.

- **URL**: https://apify.com/automation-lab/auction-com-foreclosure-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Auction.com Foreclosure Listings Scraper

Collect public Auction.com foreclosure, bank-owned (REO), and private-seller auction listings by US location or copied search URL.

Turn changing auction inventory into clean, typed records for deal sourcing, market monitoring, underwriting queues, and real-estate data pipelines.

- 🏠 Search by state, ZIP code, or `City, ST`
- 🔗 Preserve filters from copied Auction.com residential search URLs
- 💵 Capture opening bids, current bids, value signals, and auction timing
- 📍 Export addresses, coordinates, property facts, occupancy, photos, and public sale flags
- 🔁 Deduplicate listings across all searches in one run
- 🔒 Anonymous, read-only workflow with no login or bidding

### What does Auction.com Foreclosure Listings Scraper do?

The Actor opens public Auction.com residential search pages and captures the structured listing data used to render their property cards.

For each property it normalizes the listing ID, public detail URL, address, sale type, listing status, auction dates, price signals, physical attributes, location, and available public terms.

You can run one focused ZIP search or combine several markets in the same job.

The result is a default Apify dataset ready for JSON, CSV, Excel, XML, RSS, or direct API access.

### Who is it for?

#### Distressed-property investors

Build a daily acquisition queue for foreclosure and REO opportunities in selected markets.

#### Wholesalers and brokers

Find newly active listings, compare auction windows, and prioritize properties for further research.

#### Servicers and asset managers

Monitor public status, occupancy, bid, and sale-condition changes across known markets.

#### Real-estate data teams

Feed Auction.com inventory into warehouses, dashboards, valuation models, and change-detection systems.

#### Market researchers

Measure inventory mix, property characteristics, and auction activity by geography over time.

### Why use this Actor?

Manual Auction.com research is useful for one property but difficult to repeat across many markets.

This Actor makes the workflow reproducible:

- ✅ Consistent field names and data types
- ✅ Global result cap for predictable runs
- ✅ Stable deduplication by Auction.com listing ID
- ✅ Source search URL on every row
- ✅ Missing values omitted instead of represented by misleading placeholders
- ✅ Conservative browser sessions through Apify Proxy
- ✅ Public data only

### What Auction.com data can you extract?

| Category | Example fields |
|---|---|
| Identity | `listingId`, `propertyId`, `url`, `sourceUrl` |
| Address | `streetAddress`, `city`, `state`, `county`, `postalCode`, `formattedAddress` |
| Status | `listingStatus`, `listingStatusGroup`, `statusLabel` |
| Sale | `productType`, `assetType`, `saleFormat`, `venueType` |
| Auction | `auctionStart`, `auctionEnd`, `openingBid`, `currentBid`, `bidCount`, `reserveStatus` |
| Values | `sellerValue`, `estimatedValue`, `estimatedRent` |
| Property | `bedrooms`, `bathrooms`, `squareFeet`, `lotSizeAcres`, `yearBuilt` |
| Classification | `occupancyStatus`, `structureType` |
| Geography | `latitude`, `longitude` |
| Media | `primaryPhotoUrl`, `photoCount` |
| Public flags | buyer premium, financing, interior access, First Look, direct offer, reserve availability |
| Provenance | `eventCode`, `marketingTags`, `scrapedAt` |

Fields are emitted only when Auction.com supplies a meaningful value for that listing.

### How to scrape Auction.com listings

1. Open the Actor input page.
2. Keep the prefilled `GA` location for a small first run, or replace it.
3. Enter states, ZIP codes, or cities such as `Atlanta, GA`.
4. Optionally paste one or more filtered Auction.com residential search URLs.
5. Set **Maximum property listings** to the number you need.
6. Keep the default Apify proxy unless you have a specific network requirement.
7. Click **Start**.
8. Open the **Dataset** tab to preview or export the records.

A first test with 10–25 records is enough to validate your workflow before scaling up.

### Input options

#### Locations

Accepted values are:

- A two-letter state code: `GA`
- A five-digit ZIP code: `30016`
- A city and state: `Atlanta, GA`

You may provide multiple locations.

#### Auction.com search URLs

Paste public URLs beginning with:

`https://www.auction.com/residential/`

This mode is useful when you already selected filters on Auction.com and want the Actor to preserve that search path.

Login, account, bidding, and unrelated Auction.com URLs are rejected.

#### Maximum property listings

`maxItems` is a global cap after duplicates are removed.

The allowed range is 1–10,000 and the default is 20.

#### Proxy configuration

Apify datacenter proxy is enabled by default because it works with the verified browser route.

Advanced users may supply another Apify proxy configuration if their environment requires it.

### Input examples

#### Search one state

```json
{
  "locations": ["GA"],
  "maxItems": 25
}
````

#### Search a city and ZIP code

```json
{
  "locations": ["Atlanta, GA", "30016"],
  "maxItems": 100
}
```

#### Use a filtered Auction.com URL

```json
{
  "searchUrls": [
    {
      "url": "https://www.auction.com/residential/TX/active_lt/auction_date_order,resi_sort_v2_st/y_nbs"
    }
  ],
  "maxItems": 50
}
```

#### Combine URL and location modes

```json
{
  "locations": ["FL"],
  "searchUrls": [
    {
      "url": "https://www.auction.com/residential/GA/active_lt/auction_date_order,resi_sort_v2_st/y_nbs"
    }
  ],
  "maxItems": 200
}
```

### Output example

```json
{
  "listingId": "2117192",
  "propertyId": "1454629",
  "url": "https://www.auction.com/details/40-oak-terrace-dr-covington-ga-2117192",
  "sourceUrl": "https://www.auction.com/residential/GA/active_lt/auction_date_order,resi_sort_v2_st/y_nbs",
  "formattedAddress": "40 Oak Terr Dr, Covington, GA 30016, Newton County",
  "listingStatus": "AUCTION_IN_PROGRESS",
  "assetType": "BANK_OWNED",
  "auctionStart": "2026-07-13T12:00:00Z",
  "auctionEnd": "2026-07-15T15:03:20Z",
  "openingBid": 100000,
  "currentBid": 150000,
  "bedrooms": 4,
  "bathrooms": 3,
  "squareFeet": 1907,
  "yearBuilt": 2006,
  "occupancyStatus": "VACANT",
  "latitude": 33.593629,
  "longitude": -83.9259868,
  "scrapedAt": "2026-07-14T04:27:03.978Z"
}
```

Values above illustrate the output shape. Auction status and prices change at the source.

### How much does it cost to scrape Auction.com listings?

This Actor uses pay-per-event pricing. A $0.005 start charge covers browser and proxy-session startup, then each saved listing is charged once.

| Apify plan tier | Price per listing | Approx. 1,000 listings plus start |
|---|---:|---:|
| Free | $0.00059408 | $0.60 |
| Bronze | $0.00051659 | $0.52 |
| Silver | $0.00040294 | $0.41 |
| Gold | $0.00030995 | $0.31 |
| Platinum | $0.00020664 | $0.21 |
| Diamond | $0.00014465 | $0.15 |

A measured 20-listing run finished in about 31 seconds. Use a low `maxItems` value for a cheap test, then estimate a larger run from your source geography.

No item event is charged for a property skipped as a duplicate.

### Monitoring new foreclosures and auction changes

Apify schedules can run the same Actor input hourly, daily, or weekly.

A practical monitoring workflow is:

1. Create one task per market or portfolio.
2. Run the task on a regular schedule.
3. Export listing IDs, status, auction dates, and bids to your database.
4. Compare the newest dataset with the previous snapshot.
5. Notify an analyst when a listing is new or a tracked field changes.

Because every row includes `listingId`, `sourceUrl`, and `scrapedAt`, downstream change detection stays straightforward.

### Data quality and deduplication

The Actor deduplicates by Auction.com's listing ID across all supplied inputs.

It preserves source-native status and type labels instead of guessing equivalent categories.

Monetary and area values are emitted as numbers.

Auction timestamps are kept in the ISO format supplied by the source.

Optional fields are omitted when the source does not provide them.

This avoids confusing empty strings and top-level `null` values in exports.

### Tips for reliable runs

- 🎯 Start with one state, city, or ZIP and a low result limit.
- 🔗 Copy the full residential search URL after applying filters.
- 🧭 Use `City, ST`, including the comma, for city inputs.
- 📦 Split very different markets into separate tasks when you want independent schedules.
- 🔁 Use `listingId` as the primary key in your database.
- 🕒 Treat bid and status fields as snapshots that may change quickly.
- 🧾 Keep `sourceUrl` for auditability.

If a valid search has no active inventory, try a broader geography or a less restrictive Auction.com filter.

### Integrations

#### Google Sheets

Use the Google Sheets integration to maintain a review queue for acquisitions teams.

#### Airtable

Upsert records by `listingId` and create views for states, occupancy, or auction end date.

#### Slack and email

Send notifications only for newly observed IDs or important status and bid changes.

#### Webhooks

Trigger an ETL job when a scheduled run finishes.

#### Make and Zapier

Connect dataset items to CRM, due-diligence, or analyst-assignment workflows without custom infrastructure.

#### Cloud storage and warehouses

Export JSON or CSV to S3, BigQuery, Snowflake, PostgreSQL, or your preferred analytics stack.

### API usage

#### Auction.com scraper API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/auction-com-foreclosure-listings-scraper').call({
  locations: ['Atlanta, GA'],
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Auction.com scraper API with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/auction-com-foreclosure-listings-scraper").call(
    run_input={"locations": ["30016"], "maxItems": 50}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### Auction.com scraper API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~auction-com-foreclosure-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations":["TX"],"maxItems":50}'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use Auction.com data with MCP and AI agents

Connect the Actor to Claude or another MCP-compatible client through:

`https://mcp.apify.com/?tools=automation-lab/auction-com-foreclosure-listings-scraper`

Example prompts:

- “Find up to 25 active Auction.com listings in Georgia and rank them by opening bid per square foot.”
- “Collect Auction.com listings around ZIP 30016 and summarize vacant bank-owned properties.”
- “Compare today's auction dates and current bids with yesterday's saved dataset.”

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/auction-com-foreclosure-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this server under the **Claude Desktop**, **Cursor**, or **VS Code** MCP settings and authenticate with your Apify token:

```json
{
  "mcpServers": {
    "apify-auction-com": {
      "url": "https://mcp.apify.com/?tools=automation-lab/auction-com-foreclosure-listings-scraper"
    }
  }
}
```

Ask the connected client to call the Actor with a small input first, inspect the records, and then increase `maxItems`.

### Legality and responsible use

This Actor accesses anonymously visible, public listing data and performs no account or transaction actions.

Whether a particular use is permitted depends on your jurisdiction, Auction.com's terms, the volume and purpose of collection, and how you store or redistribute the data.

You are responsible for:

- Reviewing applicable terms and laws
- Using proportionate collection limits
- Respecting intellectual-property and database rights
- Protecting any derived personal or business information
- Avoiding unlawful discrimination or prohibited real-estate practices

This documentation is not legal advice.

### Troubleshooting

#### Why did my run return no listings?

The search may have no current inventory, filters may be too narrow, or Auction.com may have changed the path.

Try a state-level search with a low `maxItems` value to confirm the workflow.

#### Why was my URL rejected?

Only public HTTPS URLs under `auction.com` or `www.auction.com` with a `/residential/` path are accepted.

Login, saved-search, bidding, and arbitrary external URLs are intentionally blocked.

#### Why is a field missing?

Auction.com does not expose every field for every listing. Missing optional values are omitted rather than filled with guesses.

#### Why did a browser session fail?

Auction.com uses bot protection. The Actor retries once with a rotated proxy session and then fails clearly rather than emitting partial challenge pages as data.

#### Can I scrape sold listings?

Use a copied Auction.com residential search URL containing the desired listing-status filters. The Actor follows the public filter path in that URL.

### FAQ

#### Does this Actor require an Auction.com account?

No. It uses anonymous public residential search data.

#### Does it place bids or save searches?

No. The Actor is read-only and never automates account or transaction actions.

#### Can I search several states in one run?

Yes. Add several values to `locations`; the global `maxItems` cap applies after deduplication.

#### Can I scrape one property detail URL?

Version 1 focuses on search results. Supply a residential search URL containing that property and identify it by `listingId` or `url` in the output.

#### How fresh is the data?

Each run is a live snapshot of the public source. The `scrapedAt` field records collection time.

#### What should I use as a database key?

Use `listingId`. `propertyId` may also be useful, but a property can participate in different listing events over time.

### Related real-estate scrapers

Build a broader property-data workflow with other Automation Lab Actors:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for mainstream listings and property details
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-com-scraper) for residential inventory research
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for nearby services and local business enrichment

Use Auction.com listing coordinates or ZIP codes as join keys for downstream market enrichment.

### Support

If a valid public Auction.com residential search fails, open an Actor issue and include:

- The exact input JSON
- The run ID
- The affected search URL
- The approximate time of the run
- Whether the search works anonymously in your browser

Do not include Auction.com credentials, bidding information, or other sensitive data.

# Actor input Schema

## `locations` (type: `array`):

US state codes, ZIP codes, or cities written as City, ST. Examples: GA, 30016, Atlanta, GA.

## `searchUrls` (type: `array`):

Optional residential search URLs copied after applying filters on Auction.com.

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

Global limit after duplicate listings are removed.

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

Apify datacenter proxy is used by default. Change this only if you need a custom proxy strategy.

## Actor input object example

```json
{
  "locations": [
    "GA"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "locations": [
        "GA"
    ],
    "searchUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/auction-com-foreclosure-listings-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 = {
    "locations": ["GA"],
    "searchUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/auction-com-foreclosure-listings-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 '{
  "locations": [
    "GA"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call automation-lab/auction-com-foreclosure-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Auction.com Foreclosure Listings Scraper",
        "description": "🏠 Collect public Auction.com foreclosure, bank-owned, and private-seller auction listings with bids, dates, property facts, occupancy, coordinates, and photos.",
        "version": "0.1",
        "x-build-id": "pQ4xIKdBjJkPkh8mK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~auction-com-foreclosure-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-auction-com-foreclosure-listings-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/automation-lab~auction-com-foreclosure-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-auction-com-foreclosure-listings-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/automation-lab~auction-com-foreclosure-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-auction-com-foreclosure-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "locations": {
                        "title": "📍 Locations",
                        "type": "array",
                        "description": "US state codes, ZIP codes, or cities written as City, ST. Examples: GA, 30016, Atlanta, GA.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "GA"
                        ]
                    },
                    "searchUrls": {
                        "title": "🔗 Auction.com search URLs",
                        "type": "array",
                        "description": "Optional residential search URLs copied after applying filters on Auction.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "Auction.com search URL",
                                    "description": "A public Auction.com residential results URL.",
                                    "type": "string"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "🏠 Maximum property listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global limit after duplicate listings are removed.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Apify datacenter proxy is used by default. Change this only if you need a custom proxy strategy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```