# AuctionNinja Estate Sale Scraper — Lots, Bids & New-Lot Alerts (`scrapersdelight/auctionninja-scraper`) Actor

Scrape AuctionNinja estate-sale auctions: sales + lots with current bid, close time, photos, location, and the auction manager's name, phone & email. Filter by state, ZIP radius, city or seller. Monitor mode alerts on new lots. No login or API key. From $4 per 1,000 lots.

- **URL**: https://apify.com/scrapersdelight/auctionninja-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 1 total users, 1 monthly users, 96.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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 🥷 AuctionNinja Scraper & Estate-Sale Auction Monitor

**Scrape live AuctionNinja.com estate-sale auctions — every sale and every lot with current bid, lot #, close time, photo, full location, AND the auction manager's name, phone & email — filtered by state, ZIP radius, city, or seller. Then run it on a schedule as a new-lot monitor that pings Slack, email, or webhook the moment fresh lots drop, so you bid (or pitch) first.**

Turn AuctionNinja into a clean dataset or a real-time deal alert. No login, no API key, no browser automation — the site filters server-side, so you pull only the sales you actually want.

***

### What does AuctionNinja Scraper do?

AuctionNinja Scraper extracts **estate-sale and online auction listings** from [AuctionNinja.com](https://www.auctionninja.com) and returns clean, structured rows you can export to **JSON, CSV, Excel, or push to your app via API**. Antiques, fine art, sterling silver, coins, MCM furniture, jewelry, designer fashion, tools — liquidated by hundreds of estate-sale companies across the US.

- 🔎 **Search the way the site does** — by state, ZIP + radius, city, seller, or sale type. All server-side.
- 🔨 **Every lot** — lot #, title, current bid, time left, photo, product URL (optionally bid counts).
- 📇 **Lead-gen bonus** — each sale includes the **auction manager's name, phone & email** plus the company name: a ready-made estate-sale-company lead list.
- 📍 **Full location** — city/state, street address, latitude/longitude.
- ⏰ **Time-aware** — sale close datetime, exact start/end from the sale's structured data, per-lot countdown.
- 💸 **Buyer's premium %** per sale, so you can compute true cost before bidding.
- 🔔 **New-lot monitor** — schedule it and get **Slack / email / webhook alerts** for newly listed lots (or new sales) in your niche.

***

### What data does it extract?

For every lot (default mode):

- 🆔 `item_id`, `lot_number`, 🏷️ `title`, 🔗 `lot_url`
- 💵 `current_bid`, `has_bid`, 🔨 `bid_count` (optional), ⏳ `time_left_text`
- 🖼️ `image`
- 🛒 its sale: `sale_id`, `sale_title`, `sale_url`, `sale_close_text`, `sale_start`, `sale_end`, `sale_item_count`, 💸 `buyers_premium_pct`
- 🏢 `seller_company`, `seller_slug`, `seller_phone`
- 📇 `manager_name`, `manager_phone`, `manager_email`
- 📍 `street_address`, `city`, `state`, `zipcode`, `location`, `latitude`, `longitude`, 🚚 `fulfillment`
- ✨ `is_new` (monitor mode), 🕒 `scraped_at`

In **Sales mode** you get one row per sale — the lead list (sale + company + manager contact + location + item count), without paging through lots.

***

### Who is it for?

- 🛒 **Resellers & flippers** sourcing underpriced antiques, silver, coins, art, and furniture lots near them.
- 🚚 **Estate liquidators & pickers** watching competitors' sales and inventory mix.
- 📇 **B2B sellers targeting estate-sale companies** — the manager phone + email per sale is a ready-made outreach list.
- 📊 **Auction aggregators & price researchers** combining AuctionNinja with HiBid, MaxSold, EstateSales.net, and others.
- 🗺️ **Local-deal hunters** tracking every sale within N miles of a ZIP code.

***

### Two ways to use it

1. **Bulk scrape** — pull lots (or whole sales) for a state, ZIP radius, city, or seller into one clean dataset.
2. **New-lot monitor** *(the recurring play)* — set `monitorMode: true`, attach an **Apify Schedule** (e.g. every few hours), and the actor emits/alerts **only lots new since the last run** for your scope.

***

### How to use it (step by step)

1. Click **Try for free**.
2. *(Optional)* scope it: `state: "CT"`, or `zipcode: "06511"` + `radiusMiles: 50`, or a `seller` name.
3. *(Optional)* set `lotKeyword` (e.g. `sterling`) to only output matching lots.
4. Click **Start**, then open the **Dataset** tab to view/export.
5. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to get pinged on new lots.

#### Quick start (nationwide, first 50 lots)

```json
{ "maxLots": 50 }
```

#### Local deal radar

```json
{ "zipcode": "06511", "radiusMiles": 50, "lotKeyword": "sterling", "maxLots": 200 }
```

#### Estate-sale-company lead list (Sales mode)

```json
{ "resultType": "sales", "state": "CT", "maxLots": 100, "fetchSaleDetails": true }
```

#### New-lot monitor (cheap & fast)

```json
{
  "state": "CT",
  "lotKeyword": "rolex",
  "maxLots": 500,
  "monitorMode": true,
  "alertOnNewLot": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `resultType` | `lots` (one row per item, default) · `sales` (one row per sale / lead) |
| `state` / `zipcode` + `radiusMiles` / `city` / `seller` | server-side scope filters |
| `saleType` | `Online` (default) · `Estate` · `All` |
| `lotKeyword` | only output lots whose title contains this text |
| `maxLots` | hard cap on rows per run (0 = unlimited) |
| `maxSales` | cap on sales opened for lots (0 = as needed) |
| `fetchBidCounts` | add `bid_count` via each lot's product page (1 extra request/lot) |
| `fetchSaleDetails` | Sales mode: add exact start/end, street address, buyer's premium |
| `monitorMode`, `alertOnNewLot` | recurring watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism (datacenter is enough) |

***

### Output

Each lot (or sale) is one dataset record (fields listed above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. Bids are numbers in USD; `sale_start`/`sale_end` come from the sale's schema.org data with timezone (e.g. `2026-07-02 19:00:00 EDT`).

```json
{
  "item_id": "2784741",
  "lot_number": "1",
  "title": "Powder Horn With American Eagle & Shield Engraving, Brass Spout & Strap",
  "lot_url": "https://www.auctionninja.com/artlantic-trades/product/…-2784741.html",
  "current_bid": 1,
  "has_bid": true,
  "time_left_text": "20 days left",
  "image": "https://www.pictureserver1.auctionninja.com/pictureserver/….jpg",
  "sale_id": "24",
  "sale_title": "Great Summer Auction - Fine Art Antiques & Estate Finds",
  "sale_url": "https://www.auctionninja.com/artlantic-trades/sales/details/…-24.html",
  "sale_close_text": "Thu, Jul 02 2026 @ 7:00 PM EDT",
  "sale_start": "2026-07-02 19:00:00 EDT",
  "sale_end": "2026-07-02 20:23:39 EDT",
  "sale_item_count": 240,
  "buyers_premium_pct": 18,
  "seller_company": "Artlantic Trades XXIV",
  "street_address": "59 Greenwood Street",
  "city": "Cranston",
  "state": "RI",
  "zipcode": "02910",
  "location": "Cranston, RI",
  "latitude": 41.7798226,
  "longitude": -71.4372796,
  "manager_name": "Igor Stetsyuk",
  "manager_phone": "(401) 595-5535",
  "manager_email": "artlantictrades@gmail.com",
  "scraped_at": "2026-06-12T17:30:00.000Z"
}
```

***

### How much does it cost?

Pay-per-event — you pay for what you pull, no subscription. Suggested rates:

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each lot/sale row returned | ~$0.004 / row |
| `lot-detail-enriched` | each extra detail-page fetch (bid counts, sale details) | ~$0.004 / page |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly listed lot/sale | ~$0.02 / item |
| `alert-delivered` | each Slack/email/webhook push | ~$0.005 / alert |

*(Final per-event prices are set on the actor's pricing page.)* A 1,000-lot bulk pull ≈ **$4**.

***

### Is it legal to scrape AuctionNinja?

AuctionNinja listings are **public auction data**, browsable without a login. The auction-manager contact details are published openly by the sellers on every sale card to attract bidders. Scraping publicly available listings is generally legal, but you are responsible for your use — especially of contact data under applicable marketing/privacy laws — and you should **review the current AuctionNinja Terms of Service before commercial use or resale of the data**.

***

### FAQ

**What is AuctionNinja?**
AuctionNinja.com is a fast-growing US marketplace where estate-sale companies run online auctions — typically full-house liquidations: antiques, art, jewelry, coins, furniture, tools, collectibles.

**Do I need an account, login, or API key?**
No. The actor reads public listing data directly — no account, cookies, or API key required.

**Can I monitor new lots and get alerts?**
Yes. Turn on `monitorMode`, attach an Apify **Schedule**, and add a Slack/webhook/email channel. Each run emits and alerts **only lots new since the last run** for your scope.

**Can I filter by location?**
Yes — `state` (2-letter code), `zipcode` + `radiusMiles`, or `city`. All server-side, so runs stay small and fast.

**Can I search for specific items like sterling silver or watches?**
Yes — set `lotKeyword` (e.g. `sterling`). The actor pages through the matched sales and outputs only lots whose title contains your keyword.

**Does it return the auction company's contact info?**
Yes — every sale carries the auction manager's **name, phone, and email** plus the company name. Use `resultType: "sales"` to get a pure lead list, one row per sale.

**Does it return photos?**
Yes — each lot includes its photo URL; sales-mode rows link to the sale page.

**How do I get bid counts?**
Turn on `fetchBidCounts` — the actor opens each lot's product page and adds `bid_count` (one extra request per lot).

**What's the buyer's premium field?**
`buyers_premium_pct` is the percentage the auction company adds on top of the hammer price — pulled from each sale's structured data so you can compute true cost.

**How do I export the data?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

**Can I integrate with Make, Zapier, n8n, or my backend?**
Yes — use the webhook/Slack channels for alerts, or the Apify API to pipe the dataset anywhere.

***

### You might also like

- 🔨 Other estate & local auction scrapers (MaxSold, HiBid/k-bid, Proxibid)
- 🏛️ Government surplus auction scrapers (PublicSurplus, GSA Auctions, StorageTreasures)
- 📍 Local-listing and lead-gen scrapers

***

### Feedback

Found a missing field or want a new filter? Open an issue on the actor — fast fixes and feature requests welcome.

# Actor input Schema

## `resultType` (type: `string`):

What each dataset row is. 'Lots' = one row per auction lot (bid, photo, close time + its sale's fields). 'Sales' = one row per sale — the estate-sale lead list with the auction manager's name, phone & email.

## `state` (type: `string`):

Two-letter US state code, e.g. CT, NY, WA. Filters server-side — only matching sales are fetched. Leave empty for nationwide.

## `zipcode` (type: `string`):

ZIP-code center for a radius search. Pair with the radius below. Leave empty to skip.

## `radiusMiles` (type: `integer`):

Search radius around the ZIP code. Site default is 250; common values: 25, 50, 100, 250.

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

City-name filter (server-side), e.g. Stamford.

## `seller` (type: `string`):

Seller (auction company) name filter, e.g. 'Clearing House'. Server-side.

## `saleType` (type: `string`):

AuctionNinja sale type. 'Online' = online auctions (the default marketplace view); 'Estate' = in-person estate sales; 'All' = both.

## `lotKeyword` (type: `string`):

Only output lots whose TITLE contains this text (case-insensitive, applied client-side), e.g. 'sterling', 'rolex', 'guitar'. The actor still pages through the matched sales to find them.

## `maxLots` (type: `integer`):

Hard cap on dataset rows this run (cost/safety guard). Defaults to 50 for a fast first run — set 0 for an unlimited bulk scrape of the whole scope.

## `maxSales` (type: `integer`):

Cap on how many sales the actor opens for lots (0 = as many as needed). Useful to sample one lot-page per sale across many sales.

## `fetchBidCounts` (type: `boolean`):

Open each lot's product page to add `bid_count`. One extra request per lot — leave off for fast runs.

## `fetchSaleDetails` (type: `boolean`):

In 'Sales' mode, open each sale's page to add exact start/end datetimes, street address, organizer phone, and buyer's-premium %. One extra request per sale. (In 'Lots' mode these fields are included automatically.)

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run's seen lots/sales (per scope) and output/alert ONLY new ones. Pair with an Apify Schedule.

## `alertOnNewLot` (type: `boolean`):

In monitor mode, deliver an alert for each new lot (or sale) via the channels below.

## `webhookUrl` (type: `string`):

POST endpoint for new-lot alert payloads (Make / Zapier / n8n / custom). One JSON body per alert.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted new-lot cards.

## `emailRecipients` (type: `array`):

Email addresses for the new-lot digest (sent via apify/send-mail).

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

Proxy settings. Datacenter rotation is enough — the site has no anti-bot.

## `requestConcurrency` (type: `integer`):

Max parallel requests for bid-count enrichment. Keep modest to respect the site.

## `diagnose` (type: `boolean`):

Dev only. Dumps the raw search JSON + sale HTML to the key-value store (DEBUG\_SEARCH\_JSON / DEBUG\_SALE\_HTML) and logs the parsed first rows, then exits. Use to verify selectors; leave off for normal runs.

## Actor input object example

```json
{
  "resultType": "lots",
  "radiusMiles": 100,
  "saleType": "Online",
  "maxLots": 50,
  "maxSales": 0,
  "fetchBidCounts": false,
  "fetchSaleDetails": false,
  "monitorMode": false,
  "alertOnNewLot": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 5,
  "diagnose": false
}
```

# Actor output Schema

## `lots` (type: `string`):

The dataset of scraped records (one item per lot, or per sale in Sales mode).

# 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 = {
    "maxLots": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/auctionninja-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 = { "maxLots": 50 }

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/auctionninja-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 '{
  "maxLots": 50
}' |
apify call scrapersdelight/auctionninja-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/R8Zzq4x3An96pOLuL/builds/qazGOMBHnOuL4FYce/openapi.json