# Toomey & Co Auctions Scraper (`crawlerbros/toomeyco-auctions-scraper`) Actor

Scrape Toomey & Co (toomeyco.com) - a leading American auction house specializing in art, design, and decorative arts. Search and browse auction lots, browse upcoming and past auctions, and get detailed lot metadata including artist names, estimates, hammer prices, images, and condition reports.

- **URL**: https://apify.com/crawlerbros/toomeyco-auctions-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Toomey & Co Auctions Scraper

Scrape **Toomey & Co Auctioneers** (toomeyco.com) — a leading American auction house specializing in American art, folk art, outsider art, and decorative arts. Search the full auction archive by keyword or browse recent lots. Extracts complete lot metadata: artist name, lot title, pre-sale estimates, hammer prices, material, condition, year, country, images, and direct lot links.

No API key, no proxy, no login required.

### What this actor does

- **Search auction archive** by artist name, art style, medium, or any keyword
- **Browse recent auction lots** for an overview of Toomey & Co's latest sales
- **Rich metadata per lot** — artist, title, material, year designed, country, condition report, description
- **Capture sold prices** (hammer prices), pre-sale estimates, and lot images
- **Withdrawn lots flagged** with `isWithdrawn: true`
- **Empty fields are omitted** — clean output, no null values

### Output per lot

| Field | Type | Description |
|---|---|---|
| `lotId` | integer | Unique lot ID from Toomey's system |
| `lotNumber` | integer | Lot number within the auction |
| `title` | string | Lot title / artwork name |
| `artistName` | string | Artist / creator name |
| `estimateLow` | integer | Pre-sale low estimate in USD |
| `estimateHigh` | integer | Pre-sale high estimate in USD |
| `soldPrice` | integer | Final hammer price in USD |
| `currency` | string | Always `USD` when estimates/sold present |
| `material` | string | Medium / materials (e.g. "oil on canvas", "watercolor on paper") |
| `condition` | string | Condition report |
| `description` | string | Extended lot description / provenance |
| `yearDesigned` | string | Year the work was created |
| `country` | string | Country of origin |
| `imageUrl` | string | Direct URL to the primary lot image |
| `lotUrl` | string | Direct link to the lot detail page |
| `isWithdrawn` | boolean | `true` if the lot was withdrawn before sale |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was scraped |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchLots` | `searchLots` — search by keyword; `browseLots` — browse recent lots |
| `query` | string | `abstract painting` | Keyword to search (required for `searchLots`) |
| `maxItems` | integer | `20` | Maximum number of lots to return (1–1000) |

#### Example: search for abstract paintings

```json
{
  "mode": "searchLots",
  "query": "abstract painting",
  "maxItems": 50
}
````

#### Example: search by artist name

```json
{
  "mode": "searchLots",
  "query": "William Wegman",
  "maxItems": 100
}
```

#### Example: search for folk art

```json
{
  "mode": "searchLots",
  "query": "folk art",
  "maxItems": 50
}
```

#### Example: browse recent auction lots

```json
{
  "mode": "browseLots",
  "maxItems": 200
}
```

### Use cases

- **American art market research** — track realized prices for American artists and folk art
- **Outsider art intelligence** — monitor sales history for self-taught and outsider art works
- **Auction analytics** — compare estimates vs. sold prices to identify market trends
- **Artwork valuation** — use sold prices as comps for appraisal and insurance purposes
- **Gallery & collector sourcing** — search Toomey's archive for acquisition opportunities
- **Academic research** — gather auction data for American art history studies
- **Data aggregation** — combine with other auction house scrapers for cross-market analysis

### FAQ

**What is Toomey & Co Auctioneers?**
Toomey & Co Auctioneers is a Chicago-area auction house specializing in American fine art, folk art, outsider art, self-taught art, and decorative arts. It is known for its expertise in 20th-century American art and regularly features works by significant American artists.

**What kind of objects does Toomey & Co sell?**
Toomey specializes in American paintings, drawings, prints, folk art, outsider and self-taught art, sculpture, and decorative objects. It is particularly noted for its coverage of American artists working in traditional and contemporary styles.

**How many results can I get per run?**
Up to 1,000 lots per run (set `maxItems`). Toomey's archive pages contain all search results on a single page.

**What does `browseLots` do vs `searchLots`?**
`searchLots` searches Toomey's archive by your keyword and returns matched results. `browseLots` fetches the archive listing page without a keyword filter, showing the most recently listed auction lots.

**Are the prices hammer prices or including buyer's premium?**
Prices are as displayed on toomeyco.com's archive pages. These are typically hammer prices; buyer's premium is applied separately at time of sale.

**What does `isWithdrawn: true` mean?**
Some lots are withdrawn before the sale date. The actor flags these so you can filter them out if needed.

**Do I need a Toomey account or API key?**
No. This actor uses Toomey & Co's publicly accessible archive pages and requires no credentials.

**How fresh is the data?**
Results reflect what is publicly accessible on toomeyco.com at the time of the run. Results are typically posted within days of each auction.

# Actor input Schema

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

What to scrape.

## `query` (type: `string`):

Keyword to search for (mode=searchLots). E.g. 'abstract painting', 'folk art', 'american art'.

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

Maximum number of lots to return.

## Actor input object example

```json
{
  "mode": "searchLots",
  "query": "abstract painting",
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped Toomey & Co auction lots.

# 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": "searchLots",
    "query": "abstract painting",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/toomeyco-auctions-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": "searchLots",
    "query": "abstract painting",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/toomeyco-auctions-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 '{
  "mode": "searchLots",
  "query": "abstract painting",
  "maxItems": 20
}' |
apify call crawlerbros/toomeyco-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Toomey & Co Auctions Scraper",
        "description": "Scrape Toomey & Co (toomeyco.com) - a leading American auction house specializing in art, design, and decorative arts. Search and browse auction lots, browse upcoming and past auctions, and get detailed lot metadata including artist names, estimates, hammer prices, images, and condition reports.",
        "version": "1.0",
        "x-build-id": "4GBGfi58FSj9pNZgr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~toomeyco-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-toomeyco-auctions-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/crawlerbros~toomeyco-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-toomeyco-auctions-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/crawlerbros~toomeyco-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-toomeyco-auctions-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchLots",
                            "browseLots"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "searchLots"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search for (mode=searchLots). E.g. 'abstract painting', 'folk art', 'american art'.",
                        "default": "abstract painting"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of lots to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
