# CoinArchives Numismatic Auction Results Scraper (`crawlerbros/coinarchives-scraper`) Actor

Scrape coinarchives.com's numismatic auction-results archive -- search ancient or world coin auction lots by keyword and get auction house, lot number, description, estimate, sale price/status, date, and images.

- **URL**: https://apify.com/crawlerbros/coinarchives-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CoinArchives Numismatic Auction Results Scraper

Scrape **CoinArchives.com** — a leading numismatic auction-results archive covering ancient and world coins from dozens of major auction houses. Search by keyword and get auction house, lot number, description, pre-sale estimate, realized price (or current sale status), auction date, and images. HTTP-only, no login, no proxy required.

### What this actor does

- **Two categories:** World Coins and Ancient Coins — CoinArchives' own top-level sections
- **Rich lot data:** auction house, auction name, lot number, full description, pre-sale estimate range, realized price and currency (or upcoming/unsold/pending/withdrawn status), auction date, thumbnail and full-size images
- **Filters:** sale status, realized-price range
- **Empty fields are omitted** — every record only contains fields CoinArchives actually published for that lot

### Output per lot

- `lotId` — CoinArchives' internal lot identifier
- `auctionTitle` — full title as shown, e.g. `Classical Numismatic Group - Electronic Auction 614, Lot 887`
- `auctionHouse`, `auctionName`, `lotNumber` — parsed from `auctionTitle` when it follows the standard pattern
- `description` — full lot description as published
- `estimateLow`, `estimateHigh`, `estimateCurrency` — pre-sale estimate, when published
- `saleStatus` — `sold` / `upcoming` / `unsold` / `pending` / `withdrawn`
- `priceRealized`, `priceCurrency` — only present when `saleStatus` is `sold`
- `auctionDate` — ISO `YYYY-MM-DD`
- `thumbnailUrl`, `imageUrl` — lot photo(s)
- `lotUrl` — canonical CoinArchives lot detail page
- `category` — `World Coins` or `Ancient Coins`
- `matchedQuery` — the keyword you searched for
- `recordType: "lot"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | `morgan dollar` | Free-text keyword to search lot titles/descriptions for |
| `searchMode` | string | `simple` | `simple` (free text) / `boolean` (CoinArchives' own AND/NOT operator syntax, e.g. `morgan +uncirculated -cleaned`) |
| `category` | string | `world` | `world` (World Coins) / `ancient` (Ancient Coins) |
| `saleStatus` | string | `any` | `any` / `sold` / `upcoming` / `unsold` / `pending` / `withdrawn` |
| `minPrice` / `maxPrice` | int | – | Realized-price range; only applies to sold lots |
| `maxItems` | int | `30` | Hard cap on emitted records (1–100, see Limitations) |

#### Example: search world coins

```json
{
  "searchQuery": "morgan dollar",
  "category": "world",
  "maxItems": 30
}
````

#### Example: only sold lots above a price floor

```json
{
  "searchQuery": "george iii shilling",
  "category": "world",
  "saleStatus": "sold",
  "minPrice": 100,
  "maxItems": 50
}
```

#### Example: search ancient coins

```json
{
  "searchQuery": "athens owl tetradrachm",
  "category": "ancient",
  "maxItems": 50
}
```

### Use cases

- **Price research** — check recent realized prices for a specific coin type before buying or selling
- **Collection valuation** — benchmark your own coins against comparable recently-sold lots
- **Market monitoring** — track auction activity and pricing trends for a coin series over time
- **Dealer & auction-house research** — survey which houses are handling a given coin type
- **Numismatic cataloguing** — enrich a coin database with real auction descriptions and images

### Limitations

- **CoinArchives' free public search returns at most 100 matching lots per query**, drawn from auctions added in roughly the last six months (confirmed live). CoinArchives' own paid "CoinArchives Pro" subscription unlocks its full 10M+ record archive with deeper pagination — out of scope for a free, no-login actor. Narrow `searchQuery` for more targeted results within the free 100-lot window.
- **Why CoinArchives instead of Numista?** This actor was originally scoped as a Numista.com (en.numista.com) coin catalogue scraper. Live cloud verification showed Numista's Cloudflare front-end blocking 100% of fetch attempts from Apify's infrastructure — both the free AUTO datacenter proxy pool and the actor container's own direct egress IP were rejected with a 403 on every single attempt, confirmed across 165+ real requests spanning 3 independent cloud runs and both the search and coin-detail page endpoints. This is a genuine, current, zero-cost-unfixable block (residential proxy would be required, which this project's zero-cost policy forbids), not a code defect. CoinArchives.com is a comparable numismatics-category source — a real auction-results archive covering the same ancient/world coin space — confirmed fully reachable with no proxy and no anti-bot workaround.

### FAQ

**What's the data source?**
CoinArchives' own public auction-results search at `coinarchives.com`. This actor is an independent third-party tool and is not affiliated with or endorsed by CoinArchives.

**Do I need a proxy or login?**
No. This actor works with no configuration beyond the input fields above, and runs on the Apify free plan.

**Why do some lots have no `priceRealized`?**
Only lots with `saleStatus: "sold"` have a realized price — upcoming, unsold, pending, and withdrawn lots never had (or don't yet have) a final sale price, so those fields are omitted rather than faked.

**Why do some lots have no `auctionHouse` or `lotNumber`?**
These are parsed from the lot's title line, which is CoinArchives' own auction-house-formatted text. A small number of listings use a non-standard title format that doesn't cleanly split into house/auction/lot — the full, unparsed text is always still available in `auctionTitle`.

**How fresh is the data?**
Every run queries CoinArchives live — there is no caching.

**Can I search both ancient and world coins in one run?**
Not in a single run — `category` selects one of CoinArchives' two top-level sections per run, matching how the site itself is organized. Run the actor twice (once per category) to cover both.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword to search auction lot titles/descriptions for, e.g. `morgan dollar`, `athens owl`, `george iii shilling`.

## `searchMode` (type: `string`):

Simple matches your query as free text. Boolean lets you use AND/NOT operators in `searchQuery` (CoinArchives' own advanced search mode), e.g. `morgan +uncirculated -cleaned`.

## `category` (type: `string`):

Search within Ancient Coins or World Coins (CoinArchives' two top-level sections).

## `saleStatus` (type: `string`):

Only keep lots with this sale status.

## `minPrice` (type: `integer`):

Drop lots with a realized price below this amount (in whatever currency that lot sold in). Only applies to sold lots.

## `maxPrice` (type: `integer`):

Drop lots with a realized price above this amount. Only applies to sold lots.

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

Hard cap on emitted records. CoinArchives' free public search returns at most 100 matching lots per query (see Limitations in the README).

## Actor input object example

```json
{
  "searchQuery": "morgan dollar",
  "searchMode": "simple",
  "category": "world",
  "saleStatus": "any",
  "maxItems": 30
}
```

# Actor output Schema

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

Dataset containing all scraped CoinArchives auction lot records.

# 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 = {
    "searchQuery": "morgan dollar",
    "searchMode": "simple",
    "category": "world",
    "saleStatus": "any",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/coinarchives-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 = {
    "searchQuery": "morgan dollar",
    "searchMode": "simple",
    "category": "world",
    "saleStatus": "any",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/coinarchives-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 '{
  "searchQuery": "morgan dollar",
  "searchMode": "simple",
  "category": "world",
  "saleStatus": "any",
  "maxItems": 30
}' |
apify call crawlerbros/coinarchives-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinArchives Numismatic Auction Results Scraper",
        "description": "Scrape coinarchives.com's numismatic auction-results archive -- search ancient or world coin auction lots by keyword and get auction house, lot number, description, estimate, sale price/status, date, and images.",
        "version": "1.0",
        "x-build-id": "wAk6OeY3fP47Hfyxv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~coinarchives-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-coinarchives-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~coinarchives-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-coinarchives-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~coinarchives-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-coinarchives-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword to search auction lot titles/descriptions for, e.g. `morgan dollar`, `athens owl`, `george iii shilling`.",
                        "default": "morgan dollar"
                    },
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "simple",
                            "boolean"
                        ],
                        "type": "string",
                        "description": "Simple matches your query as free text. Boolean lets you use AND/NOT operators in `searchQuery` (CoinArchives' own advanced search mode), e.g. `morgan +uncirculated -cleaned`.",
                        "default": "simple"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "world",
                            "ancient"
                        ],
                        "type": "string",
                        "description": "Search within Ancient Coins or World Coins (CoinArchives' two top-level sections).",
                        "default": "world"
                    },
                    "saleStatus": {
                        "title": "Sale status filter",
                        "enum": [
                            "any",
                            "sold",
                            "upcoming",
                            "unsold",
                            "pending",
                            "withdrawn"
                        ],
                        "type": "string",
                        "description": "Only keep lots with this sale status.",
                        "default": "any"
                    },
                    "minPrice": {
                        "title": "Min realized price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop lots with a realized price below this amount (in whatever currency that lot sold in). Only applies to sold lots."
                    },
                    "maxPrice": {
                        "title": "Max realized price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop lots with a realized price above this amount. Only applies to sold lots."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on emitted records. CoinArchives' free public search returns at most 100 matching lots per query (see Limitations in the README).",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```