# Bidsquare Scraper - Auction House Contacts & Lots (`scrapersdelight/bidsquare-lot-scraper`) Actor

From $4.50 per 1,000 rows, no start fee. Bidsquare's whole 505-house auctioneer directory - phone, email, street address, coordinates, socials - plus every catalogue lot with estimate, current bid, bid count, condition, premium and the realized hammer price hidden behind 'Login for Price'.

- **URL**: https://apify.com/scrapersdelight/bidsquare-lot-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.50 / 1,000 per row delivereds

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

## 🏛️ Bidsquare Scraper — Auction House Contacts & Lots

Two things nobody else pulls out of [Bidsquare](https://www.bidsquare.com) in one place: **the full
auctioneer directory as a contact list**, and **every catalogue lot with the realized hammer price
the site hides behind a login button**.

- 📇 **505 auction houses** — name, phone, email, street, city, state, postcode, country, map
  coordinates, logo and social profiles.
- 🔨 **~48,300 lots** currently on the upcoming calendar across **132 sales**, plus a closed-sale
  archive **91 pages deep**.
- 💰 **Realized hammer prices on closed lots.** Bidsquare replaces the price with a *"Login for
  Price"* button — but its own schema.org block still publishes the number. This Actor reads it.
- 📍 Every lot row can carry the selling house's phone, email and address, joined on for you.
- 💵 **$4.50 per 1,000 rows. No run-start fee.** Both row shapes cost the same.

Everything below is a number measured on a real run through an Apify proxy on **2026-09-18**, not an
estimate. Where a field is sparse, the real percentage is printed rather than hidden.

***

### What does Bidsquare Scraper do?

Bidsquare is a US marketplace where independent auction houses run fine-art, antiques, jewellery,
coin and collectible sales. Two useful datasets sit inside it, and this Actor returns either.

#### Mode 1 — `auction-houses` (the default): the contact directory

One row per auction house. This is the deliverable if you sell **to** auction houses, build price
databases, do estate liquidation, or need an appraiser/insurer panel.

| Field | Fill (505 houses, measured) |
|---|---|
| `name` | **100%** |
| `email` | **100%** |
| `postalCode` · `country` · `bidsquareSellerId` | **100%** |
| `city` | **99.8%** |
| `street` | **99.4%** |
| `phone` · `phoneE164` | **99.2%** |
| `logoUrl` | **97.6%** |
| `state` | **90.7%** (blank where the country has no state/region line) |
| `latitude` · `longitude` | **81.2%** (the rest publish no geocode — `null`, never `0,0`) |
| `facebookUrl` | **53.5%** |
| `instagramUrl` | **52.5%** |
| any social profile | **60.4%** |
| `twitterUrl` | **23.8%** |
| `description` | **33.3%** (only a third of houses write a storefront blurb) |
| `upcomingAuctionCount` · `upcomingLotCount` | **100%** (a real count, `0` where nothing is on the calendar) |
| `nextAuctionUrl` · `nextAuctionName` | **12.5%** — the 63 houses with a sale scheduled |

Also on every house row: `slug`, `profileUrl`, `contactUrl`, `pastSalesUrl`, `addressLines` (the raw
address exactly as printed), `isListedInDirectory`, `linkedinUrl`, `pinterestUrl`, `youtubeUrl`,
`scrapedAt`.

**Geography measured on the full 505:** 429 United States (across 41 states), 24 United Kingdom,
12 Canada, 7 Mexico, 5 Italy, 4 Germany, 4 France, 3 Spain, 3 Austria, and a long tail —
**419 distinct email domains**, so these are the houses' own inboxes, not a shared platform address.

#### Mode 2 — `lots`: catalogue lots

One row per lot, from the upcoming calendar or the closed archive.

| Field | What it is |
|---|---|
| `lotId` · `lotNumber` · `title` · `lotUrl` · `imageUrl` | identity; **100%** on 4,298 lots measured |
| `estimateLow` · `estimateHigh` · `estimateCurrency` · `estimateDisplay` | the estimate band; **99.8%** |
| `currentPrice` · `currentPriceDisplay` · `currentPriceLabel` | current bid, starting bid or Buy Now price, and which of those it is |
| `bidCount` | bids placed, where the sale shows it |
| `hammerPriceLoginWalled` | `true` when Bidsquare has replaced the price with a login button |
| `realizedPrice` · `saleStatus` · `schemaAvailability` | **sold / unsold / open**, and the hammer price on `sold` — needs `lotDetails` |
| `condition` · `categories` · `buyersPremiumPercent` · `shippingInfo` · `description` · `images` | with `lotDetails` |
| `eventId` · `eventName` · `eventUrl` · `eventStatus` · `auctionType` · `eventDatesText` · `eventTimezone` | the sale |
| `houseName` · `houseSlug` · `houseProfileUrl` | the seller |
| `housePhone` · `houseEmail` · `houseStreet` · `houseCity` · `houseState` · `housePostalCode` · `houseCountry` · `houseLatitude` · `houseLongitude` | with `includeHouseContact` (on by default) — **100%** on 4,298 lots |

***

### The realized-price wedge, and how it was verified

On a closed sale, the catalogue page shows an estimate and a **"Login for Price"** button — measured
at **85.2%** of 4,298 lots across ten closed sales. The lot page shows the same button. But the lot
page also carries a schema.org `Product` block, and that block still publishes the price:

```json
"offers": { "price": 125, "priceCurrency": "USD", "availability": "SoldOut" }
```

Setting `lotDetails: true` reads it. On a 250-lot sale walked end to end: **228 sold lots, 228
realized prices (100%), 12 unsold lots, 0 realized prices** — because `availability: Discontinued`
means the lot did *not* sell and its `price` is only the last standing bid. An unsold lot is never
reported as sold.

**Why it is the hammer price and not a restated estimate.** Checked on 24 closed lots from one sale:
the published price equalled the estimate midpoint on only **2 of 24**, and ranged from **$50 against
a $100–150 estimate** to **$2,500 against a $200–300 estimate**. An estimate cannot do that.

***

### How much data is there?

Every figure re-measured against the live site on 2026-09-18:

| | Measured |
|---|---|
| Auction houses in Bidsquare's sitemap | **505** |
| …of those, listed in the public `/directory` | **210** |
| …of those, with a sale on the calendar | **63** |
| Upcoming sales | **132** |
| Lots advertised across those sales | **48,320** |
| Largest single catalogue seen | **2,999 lots** |
| Closed-sale archive | **91 pages × 24 sales ≈ 2,180 sales** |

A full-directory run — all 505 houses — takes **513 requests** and returned **505 / 505 rows with 0
failures and 0 blocks**.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | select | `auction-houses` | `auction-houses` or `lots` |
| `houseScope` | select | `all` | `all` (505) or `selling-now` (63) |
| `houseSlugs` | array | `[]` | Limit to specific houses — slug or profile URL |
| `auctionStatus` | select | `upcoming` | `upcoming`, `past` or `both` |
| `auctionUrls` | array | `[]` | Scrape exactly these sale catalogues |
| `maxAuctions` | integer | `5` | Catalogues to walk; `0` = no limit |
| `keywords` | array | `[]` | Keep only lots matching these words |
| `minEstimate` / `maxEstimate` | integer | — | Estimate-band filter |
| `onlyWithEstimate` | boolean | `false` | Drop lots with no published estimate |
| `lotDetails` | boolean | `false` | One request per lot: realized price, condition, category, premium, all photos |
| `includeHouseContact` | boolean | `true` | Join the selling house's contact onto each lot row |
| `maxRecords` | integer | `75` | Hard cap on rows delivered **and charged**; `0` = no limit |
| `maxConcurrency` | integer | `8` | Parallel requests |
| `proxyConfiguration` | object | Apify Proxy | Datacenter measured at 513/513 on 2026-09-18 |

#### Example: the whole contact directory

```json
{ "mode": "auction-houses", "houseScope": "all", "maxRecords": 0 }
```

#### Example: houses with a sale on the calendar right now

```json
{ "mode": "auction-houses", "houseScope": "selling-now", "maxRecords": 0 }
```

#### Example: realized prices from closed sales

```json
{ "mode": "lots", "auctionStatus": "past", "maxAuctions": 3,
  "lotDetails": true, "maxRecords": 500 }
```

#### Example: watches and jewellery on the upcoming calendar over $1,000

```json
{ "mode": "lots", "auctionStatus": "upcoming", "maxAuctions": 20,
  "keywords": ["Rolex", "Cartier", "diamond"], "minEstimate": 1000, "maxRecords": 2000 }
```

#### A real row (from the verified run, trimmed)

```json
{
  "recordType": "auction-house",
  "slug": "clars-la",
  "name": "Clars LA Auctions",
  "bidsquareSellerId": 906,
  "phone": "(626) 766-1616",
  "phoneE164": "+16267661616",
  "email": "ask@clarsla.com",
  "street": "818 W Las Tunas Dr",
  "city": "Los Angeles",
  "state": "CA",
  "postalCode": "91776",
  "country": "United States",
  "latitude": null,
  "longitude": null,
  "instagramUrl": "https://www.instagram.com/clarsauctiongalleryla",
  "isListedInDirectory": true,
  "upcomingAuctionCount": 0,
  "upcomingLotCount": 0,
  "profileUrl": "https://www.bidsquare.com/auction-house/clars-la"
}
```

***

### Pricing

**Pay per event. One event, `record-scraped`, charged once for each row delivered — $0.0045 a row,
i.e. $4.50 per 1,000. There is no run-start fee**, so a run that matches nothing costs nothing.

| Run | Rows | Cost |
|---|---|---|
| The whole 505-house contact directory | 505 | **$2.27** |
| Houses with a sale on the calendar | 63 | **$0.28** |
| One 450-lot catalogue with house contacts | 450 | **$2.03** |
| A 250-lot closed sale with realized prices | 250 | **$1.13** |

Filtered-out lots are never delivered and never charged. A house whose page exists but publishes no
contact at all is reported in the run summary and **not** charged. The row cap counts rows
*produced*, so `maxRecords: 60` charges exactly 60 — never a flushed batch of 100.

***

### Honest limits

- **Realized prices need `lotDetails: true`.** The catalogue listing genuinely has no price for a
  closed lot — measured 0 of 96 on a closed-sale page. One extra request per lot is the cost of it.
- **Bidsquare does not publish a house's own website URL** anywhere on its profile or contact page,
  so there is no `website` field. The email domain is usually the site (419 distinct domains on 505
  houses).
- **`condition` and `categories` vary by house, not by parser.** Some houses publish a full condition
  report and a category path on every lot page; others publish neither — on one 240-lot sale walked
  with `lotDetails` both came back empty for all 240, and the raw bytes confirm the page carries an
  empty `auction-category` block and no condition section at all.
- **`description` is only written by a third of houses** (168 of 505). It is `null`, not an empty
  string, on the rest.
- **Coordinates are `null` on 18.8% of houses.** Bidsquare writes `0` there and geocodes in the
  browser; `0,0` is a point in the Atlantic, so it is reported as `null`.
- **`limit=120` is broken on Bidsquare's own pagination** — a 450-lot catalogue reachable at
  `limit=96` returns only 330 lots at 120, because page 4 silently re-serves page 1. This Actor pins
  96 and stops on "no new lot ids", and every catalogue it walked reconciled **exactly** to the
  sale's own results counter (4,298 reported / 4,298 read across ten sales).
- **Bid counts and current prices only exist while a lot is open.** Across ten closed sales,
  `currentPrice` filled on 12.5% of rows and `hammerPriceLoginWalled` on 85.2% — that is the source,
  not a parse failure, and the flag tells you which is which.

***

### Reliability and how it behaves when something goes wrong

- A non-200 is treated as a **transport failure**, retried on a **fresh proxy session**, and listed
  in `RUN_SUMMARY.unreachable` — never as "end of data".
- An HTTP 200 carrying a challenge page is counted as blocked, not as an empty result.
- Bodies are checked against `Content-Length` before parsing, because a multi-hundred-KB page can die
  mid-stream under HTTP 200 on a datacenter proxy.
- Every catalogue is **floor-asserted** against the sale's own "N Results" counter.
- The 505-house sitemap parse is floor-asserted too: if it yields fewer than 300 houses the run
  **fails** rather than shipping a partial directory.
- A run where more than half the requests fail **fails loudly**. A run that legitimately matched
  nothing **exits clean** with zero rows and zero charge.
- `RUN_SUMMARY` (in the key-value store) keeps the three kinds of nothing apart — *does not exist* ·
  *exists but publishes no contact* · *unreachable after retries* — and charges for none of them.

***

### FAQ

**Can I get sold prices / prices realized?**
Yes. `mode: "lots"`, `auctionStatus: "past"`, `lotDetails: true`. `realizedPrice` is filled on every
lot whose `saleStatus` is `sold`; it stays `null` on `unsold`.

**Do I need a Bidsquare account?**
No. Everything this Actor reads is served to a logged-out visitor.

**Does it use a browser?**
No. Bidsquare renders its directory, catalogues and lot pages server-side, so this is plain HTTP at
1,024 MB — which is why a full 505-house directory is 513 requests and a few minutes.

**How do I get every house in one file?**
`{ "mode": "auction-houses", "maxRecords": 0 }`. That is 505 rows, $2.27.

**How do I get the houses worth calling this week?**
`houseScope: "selling-now"` — the 63 houses with a sale on the calendar, each row carrying
`upcomingAuctionCount`, `upcomingLotCount` and the next sale's name, URL and start time.

**Can I filter by category, artist or keyword?**
`keywords` matches lot titles (and descriptions when `lotDetails` is on). Bidsquare's `/search`
endpoint is `Disallow`ed in its robots.txt, so this Actor filters catalogue lots it has already
read rather than querying that endpoint.

**Why is `currentPrice` empty on so many of my rows?**
Because those lots have closed and Bidsquare has replaced the price with a login button —
`hammerPriceLoginWalled` will be `true` on exactly those rows. Turn on `lotDetails` to get
`realizedPrice` instead.

**What happens if a lot or house disappears mid-run?**
It is recorded in `RUN_SUMMARY.notFound` and not charged.

**Can I monitor a specific house?**
`houseSlugs: ["clars-la"]` in either mode. In `lots` mode only that house's sales are walked.

**How big can one run get?**
The largest single catalogue measured was 2,999 lots, and it walked to the last lot exactly
(31 pages of 96 plus a final 23 = 2,999).

**Does the row cap really cap the bill?**
Yes. Rows are delivered through Apify's budget-aware push, so delivered always equals charged.

***

### Source and legal

Data comes from public pages on `https://www.bidsquare.com` — the auctioneer directory, sale
calendars, catalogue pages and lot pages, all served to a logged-out visitor.

**Why auction houses are named on every sale:** US state auctioneer-licensing statutes require the
licensed auctioneer to be identified on an advertised sale — Ohio R.C. 4707.22, the Pennsylvania
Auctioneer Licensing Act (63 P.S. §734) and Texas Occupations Code ch. 1802 among them — so the
selling house is named on each catalogue. Bidsquare's own house profiles carry the address and
phone by directory convention.

**`robots.txt` (fetched 2026-09-18), quoted verbatim.** The disallowed paths are:

```
Disallow: /my-bidsquare
Disallow: /my-account
Disallow: /admin
Disallow: /seller
Disallow: /user
Disallow: /search
Disallow: /*?*category=
Disallow: /category/*?*page=
Disallow: /*?*search=
Disallow: /*?*filters=
Disallow: /*?*sort=
Disallow: /*?*default=
Disallow: /user/register/*
Disallow: /user/register?*
Disallow: /register/*
Disallow: /register?*
Disallow: /*?*is_ajax=
Allow: /user/register
```

There is no blanket `Disallow: /`. This Actor reads only `/directory`,
`/sitemap-auction-house.xml`, `/auction-house/<slug>/contact-us`, `/auctions[?page=N]`,
`/auctions/past[?page=N]`, `/auctions/<house>/<sale>?limit=96[&page=N]` and
`/online-auctions/<house>/<lot>` — none of which appears above, and the offline test suite asserts
that for each URL template. It does **not** use `/search` or the `?is_ajax=` endpoints, which is why
the per-house sale count is counted off `/auctions` rather than taken from the directory's
"View All Upcoming" button.

Not affiliated with, endorsed by, or connected to Bidsquare. Check Bidsquare's Terms of Service and
your own obligations before using the output; how you use contact data is your responsibility.

# Actor input Schema

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

Auction houses (default) returns one row per auction house on bidsquare.com — name, phone, email, street address, city/state/postcode, coordinates, logo and social profiles, plus how many sales that house currently has on the calendar. Lots returns one row per catalogue lot — estimate band, current or asking price, bid count, lot number, image and the selling house's contact joined on. Both row shapes cost the same per row.

## `houseScope` (type: `string`):

Auction-houses mode only. All houses reads bidsquare's own sitemap — 505 houses on 2026-09-18, including the ones with nothing on the calendar right now. Selling now keeps only the houses with an upcoming sale (63 on 2026-09-18), which is the warmer list if you are pitching a service that depends on active sale volume.

## `houseSlugs` (type: `array`):

Optional. Limit the run to these houses. Accepts a slug ("clars-la") or a full profile URL ("https://www.bidsquare.com/auction-house/clars-la"). In auction-houses mode these become the rows; in lots mode only sales run by these houses are walked. Leave empty for every house.

## `auctionStatus` (type: `string`):

Lots mode only. Upcoming walks the live sale calendar (132 sales, ~48,300 advertised lots on 2026-09-18). Past walks the closed-sale archive, which is 91 pages deep — that is where realized hammer prices live, so pair it with "Fetch each lot page".

## `auctionUrls` (type: `array`):

Optional. Scrape exactly these sale catalogues instead of walking the calendar — paste any bidsquare auction URL, for example https://www.bidsquare.com/auctions/millea-bros/abc-estate-finds-books-day-3-of-3-24704. A /catalog suffix or query string is stripped for you.

## `maxAuctions` (type: `integer`):

Lots mode only. How many sale catalogues to page through before stopping. Set 0 for no limit. Catalogues run from a few dozen lots to nearly 3,000, so this is the main cost lever alongside the row cap.

## `keywords` (type: `array`):

Optional. Keep only lots whose title (or description, when lot pages are fetched) contains one of these words — for example "Rolex", "Tiffany", "Qing". Matching is case-insensitive. Filtered-out lots are never delivered and never charged.

## `minEstimate` (type: `integer`):

Optional. Drop lots whose high estimate is below this figure, in the sale's own currency. Lots with no published estimate are dropped too.

## `maxEstimate` (type: `integer`):

Optional. Drop lots whose low estimate is above this figure, in the sale's own currency.

## `onlyWithEstimate` (type: `boolean`):

Drop lots that carry no estimate band. Buy Now sales price their lots outright and publish no estimate, so this filter removes those entirely.

## `lotDetails` (type: `boolean`):

Lots mode only, and one extra request per lot. Adds the full description, the condition report, the category path, the buyer's premium percentage, every photo, the sale timezone — and the realized hammer price. Closed lots replace their price with a "Login for Price" button on the catalogue page, but the lot page still publishes it in schema.org, so this is the only way to get prices realized. Off by default because it multiplies the request count by about 96.

## `includeHouseContact` (type: `boolean`):

Lots mode only. Adds the house's phone, email, street, city, state, country and coordinates to each lot row. Costs one extra request per distinct house in the run, not per lot, because the contact page is fetched once and cached.

## `maxRecords` (type: `integer`):

Hard cap on rows delivered, and therefore on what you are charged — the cap is counted against rows produced, not batches flushed, so a cap of 60 charges exactly 60. Set 0 for no limit; the whole 505-house directory is one run at 0. Left at the default a run stops at 75 rows, which is a $0.34 ceiling on an accidental run.

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

How many pages to fetch at once. 8 is a good balance: bidsquare answered 60 concurrent house pages in 9 seconds at this setting with no throttling. Lower it if you see failures in the run summary.

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

Apify Proxy is strongly recommended — bidsquare.com sits behind Cloudflare. The datacenter pool was measured at 60/60 successful house pages and 100% on catalogue pages on 2026-09-18; switch to RESIDENTIAL if the run summary starts reporting blocked responses.

## Actor input object example

```json
{
  "mode": "auction-houses",
  "houseScope": "all",
  "houseSlugs": [],
  "auctionStatus": "upcoming",
  "auctionUrls": [],
  "maxAuctions": 2,
  "keywords": [],
  "onlyWithEstimate": false,
  "lotDetails": false,
  "includeHouseContact": true,
  "maxRecords": 25,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per auction house (name, phone, email, street, city, state, postcode, country, coordinates, logo, social profiles, sales and lots currently on the calendar) or one row per catalogue lot (lot number, title, estimate band, current or asking price, bid count, image, sale, and the selling house's contact joined on — plus condition, category, buyer's premium, every photo and the realized hammer price when lot pages are fetched).

## `runSummary` (type: `string`):

RUN\_SUMMARY: what bidsquare.com said was there against what was actually read and delivered — rows delivered (which equals rows charged), houses or catalogues walked against the source's own totals, lots dropped by your filters, duplicate lot ids skipped, per-field fill counted on this run's own rows, and the three kinds of nothing kept apart (does not exist · exists but publishes no contact · unreachable after retries), none of which is charged.

# 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": "auction-houses",
    "maxAuctions": 2,
    "lotDetails": false,
    "includeHouseContact": true,
    "maxRecords": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/bidsquare-lot-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": "auction-houses",
    "maxAuctions": 2,
    "lotDetails": False,
    "includeHouseContact": True,
    "maxRecords": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/bidsquare-lot-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": "auction-houses",
  "maxAuctions": 2,
  "lotDetails": false,
  "includeHouseContact": true,
  "maxRecords": 25
}' |
apify call scrapersdelight/bidsquare-lot-scraper --silent --output-dataset

```

## MCP server setup

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