# Goldin Auction Lots Scraper (`automation-lab/goldin-auction-lots-scraper`) Actor

Extract public Goldin auction lots and supplied item URLs with lot identity, titles, displayed bids, closing dates and optional detail descriptions for collectible price research.

- **URL**: https://apify.com/automation-lab/goldin-auction-lots-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 item extracteds

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

Learn more: https://docs.apify.com/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

## Goldin Auction Lots Scraper

Collect public **Goldin auction lots** for recurring collectible price research. Export lot identity, titles, displayed bids, bid counts, closing dates and optional plain-text detail descriptions. Dealers can build dated snapshots in a spreadsheet or database without opening each lot manually.

This Actor reads public Goldin data. It does not bid, authenticate to accounts, send alerts, or reconstruct an exhaustive historical archive. It is independently operated and is not affiliated with or endorsed by Goldin or eBay.

### Who is it for?

- Collectible dealers comparing current asking/bid activity before consigning inventory.
- Sports-card researchers collecting consistent lot IDs and dated price observations.
- Analysts combining auction lots with separate regional-sale or vehicle-auction feeds.

### Why use this Actor?

Use one typed row per unique accepted lot, rather than parsing page HTML. The direct public API route avoids downloading images or launching a browser. Supplied URLs provide a reproducible way to revisit the same lots, including older completed lots that still resolve publicly.

A displayed bid is not a completed transaction. Keep `status` and `scrapedAt` beside every price observation.

### Getting started

1. Open the input form.
2. Leave supplied URLs empty to discover current public lots.
3. Optionally enter a title substring, such as `pikachu`.
4. Set the global maximum lots and discovery page cap.
5. Run once and inspect the Auction lots output.
6. Export JSON, CSV, Excel or XML using Apify dataset exports.

```json
{"maxItems":10,"maxPages":10,"includeDescriptions":true}
```

### Collect goldin auction lots by URL

```json
{
  "lotUrls":["https://goldin.co/auctions/2017-nick-markakis-game-used-atlanta-braves-road-independence-day-jersgf6ox"],
  "keyword":"markakis",
  "maxItems":10
}
```

Nonempty URL lists replace discovery; an empty list uses discovery. Both current `/item/<slug>` and legacy `/auctions/<slug>` paths are accepted. The output uses the current item URL. Repeated URLs and equivalent legacy/current paths are deduplicated.

### Inputs and matching semantics

| Input | Default | Behavior |
|---|---|---|
| `lotUrls` | `[]` | At most 1000 HTTPS Goldin lot URLs; nonempty replaces discovery. |
| `keyword` | Empty | Case-insensitive contiguous title substring; outer whitespace trimmed. |
| `maxItems` | 10 | Global accepted unique-lot limit, 1–1000; zero is invalid. |
| `maxPages` | 10 | Discovery-only cap of 1–100 requests, up to 50 source lots per page. |
| `includeDescriptions` | true | Fetch detail descriptions for accepted discovery lots. |

The keyword filter applies to supplied URLs and discovered lots alike. It does not require whole-word boundaries or match descriptions. Discovery also sends the keyword to Goldin's search engine, whose ranking and coverage may further restrict candidates. No guarantee of exhaustive keyword coverage is made.

Discovery normally returns live/preview auction inventory. Completed lots are supported only through supplied URLs. The run stops at the result limit, page cap or source exhaustion, whichever comes first. The SUMMARY output records pages, scanned rows and caps reached.

### Extracted fields

| Field | Meaning |
|---|---|
| `lotId` | Stable source lot ID, suitable for joining snapshots. |
| `url` | Public item URL. |
| `title` | Source title, not an AI-generated summary. |
| `lotNumber` | Auction lot number, nullable. |
| `auctionId`, `auctionType` | Source auction ID and tier, nullable. |
| `auctionTitle` | Detail-derived auction name, nullable. |
| `status` | Raw source status such as Live or Completed_Sold. |
| `currentBid` | Source current_price in USD, nullable. |
| `minimumBid`, `bidCount` | Source minimum bid and number of bids, nullable. |
| `currency` | USD. |
| `closesAt`, `startsAt` | Source timestamps, nullable; extended bidding can change closure. |
| `description` | Plain-text detail description or null. |
| `scrapedAt` | UTC extraction time. |

With descriptions disabled, discovery skips per-lot details and sets both description and auctionTitle to null. Supplied URLs always require a detail lookup; disabling descriptions suppresses their description but retains their available auction title.

### Example output

This shortened example comes from a public completed lot; description is abbreviated here only.

```json
{
  "lotId":"201806-1020-0000-39aee8f8-39ae-e8f8-54e9-47a99f8af42e",
  "url":"https://goldin.co/item/2017-nick-markakis-game-used-atlanta-braves-road-independence-day-jersgf6ox",
  "title":"2017 Nick Markakis Game Used Atlanta Braves Road Independence Day Jersey Photo Matched To 7/2/17 (MLB Authenticated & Resolution Photomatching)",
  "lotNumber":36236,
  "auctionType":"Weekly",
  "status":"Completed_Sold",
  "currentBid":325,
  "minimumBid":200,
  "bidCount":1,
  "currency":"USD",
  "closesAt":"2018-06-24T00:57:00Z",
  "description":"Atlanta Braves right fielder Nick Markakis wore this button-down Majestic FlexBase size 46 road gray jersey..."
}
```

Buyer premium, taxes and shipping are not added. `currentBid` must not be described as an all-in buyer-paid sale total.

### How much does it cost to extract Goldin auction lots?

Pay-per-event pricing charges a one-time start event and one item event per unique accepted lot delivered. Details are included in the lot event, not separately charged. Duplicate, rejected or failed records are not charged as items.

The start fee is $0.0001 per run. Per-lot prices:

| Spend tier | Price per lot | Price per 1000 lots |
|---|---:|---:|
| FREE | $0.0017245 | $1.7245 |
| BRONZE | $0.0014996 | $1.4996 |
| SILVER | $0.0011697 | $1.1697 |
| GOLD, PLATINUM, DIAMOND | $0.00089976 | $0.89976 |

At BRONZE, one lot costs approximately $0.0015996, ten lots $0.015096, and 100 lots $0.15006 including the start fee. Check the pricing panel for your applicable tier. Spend tiers follow Apify's aggregate monthly Store spend rules, not this Actor's row count.

Customer totals and earnings estimates can be adjusted for refunds, fraud, disputes, taxes, corrections and contractual clawbacks. No payout is guaranteed.

### Limits and failure behavior

- No login, private accounts, bidding, notification or historical enumeration.
- Inventory can change while pages are being collected; snapshots are not transactional.
- Search ordering and completeness are controlled by Goldin.
- Three total attempts for transient network failures, 429 and server errors; no infinite retry.
- Permanent HTTP errors, invalid response shapes and mismatched detail IDs fail the run rather than masquerading as empty results.
- A failed run may retain partial delivered rows; inspect terminal status before using it as a complete snapshot.
- Unknown input fields and invalid limits are rejected.

### Integrations

Export a dated snapshot to Google Sheets, then join on lotId to compare displayed bids. Store raw source status so completed lots are not confused with live inventory. Schedule recurring runs with Apify schedules if you want snapshots; this Actor itself does not send alerts or track changes between runs.

For larger datasets, stream exports to your own database rather than placing every description in an AI prompt. Webhooks can trigger your own downstream workflow after a successful run.

### API usage

Set your Apify token in your environment; do not put it into shared URLs.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~goldin-auction-lots-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":10,"keyword":"pikachu"}'
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/goldin-auction-lots-scraper').call({ maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/goldin-auction-lots-scraper').call(run_input={'maxItems': 10})
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### MCP setup

Claude Code:

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

Claude Desktop, Cursor, and VS Code: use the equivalent HTTP server configuration in clients supporting remote MCP, and authorize with your Apify account:

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

Example prompt: “Collect ten public Goldin lots with pikachu in their title. Show lot IDs, displayed bids and closing dates; do not call the price a realized sale.”

Discover actual tool names and input schemas through scoped tools/list. The Actor selection also adds run/storage helpers, not exactly one tool. Only invoke a run when authorized. Start once, retain its run and storage IDs, and follow that same run. If call-actor returns before completion (waitSecs is at most 45), use get-actor-run with bounded 2/4/8-second backoff capped at ten seconds and a 120-second total deadline. On timeout, recover the known run rather than starting another; report uncertainty if the run ID is unknown.

After success, read get-dataset-items with explicit limit, offset and needed fields. A reasonable consumer budget is 20 source rows per page, at most 100 rows and 64 KiB of serialized UTF-8 results admitted to model context. Enforce byte limits host-side; omit or summarize oversized descriptions with disclosure. Stop at the deadline/budget and report pending or truncated results honestly. Full exports belong outside model context. If the client cannot intercept oversized responses, no hard byte guarantee is implied. Discovery bytes and client-side caching do not guarantee model token savings.

### Legality and data handling

Use public collectible data responsibly and respect applicable laws, source terms and intellectual-property rights. Source descriptions may contain names of public figures or sellers; no account profiles or private customer records are collected. The Actor performs no AI inference and sends no input or scraped data to an AI provider at runtime.

Apify stores input, datasets, summary and logs according to your account retention/settings. Delete runs and storage through Apify when no longer needed. No cross-run cache or cookies are retained by this Actor. Public lot slugs are sent to Goldin's public detail service; the company pays infrastructure costs. No external paid API or proxy key is required.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed, and reports are retained for 30 days. Avoid entering secrets into unsupported input fields. Logs contain counts and error messages, not full descriptions.

### Troubleshooting and FAQ

**Why are fewer lots returned than maxItems?** The source can exhaust, the title filter can reject rows, or maxPages can stop collection. Check SUMMARY.

**Why does a lot URL fail?** Use a public HTTPS `/item/` or legacy `/auctions/` lot path, not an auction landing page. Deleted or inaccessible items fail explicitly.

**Can I obtain every historical sale?** No. Supply known completed lot URLs; historical archive enumeration is outside scope.

**Does it calculate card grades or send bid alerts?** No. Titles and descriptions are source text, and each run is a snapshot.

**How do I report a problem?** Use the Actor's Apify Issues tab with the run link and a non-secret reproduction input. We aim to give a substantive response within 14 calendar days.

### Related Actors

- [AuctionZip Auction Listings Scraper](https://apify.com/automation-lab/auctionzip-auction-listings): regional upcoming auction discovery, a different entity from collectible lots.
- [Copart Auction Data Scraper](https://apify.com/automation-lab/copart-auction-data-scraper): vehicle-auction research; join only in a downstream multi-source workflow.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/goldin-auction-lots-scraper/changelog.md

# Actor input Schema

## `lotUrls` (type: `array`):

Optional HTTPS Goldin /item/<slug> or legacy /auctions/<slug> URLs. A nonempty list replaces discovery. Duplicates are removed; unavailable URLs fail the run. Supplied URLs can be completed lots. An empty list uses discovery.

## `keyword` (type: `string`):

Optional case-insensitive contiguous substring in the lot title, with outer whitespace trimmed. Applied to both supplied URLs and discovery. Discovery also sends the phrase to Goldin search, so source search ranking and coverage can further restrict matches. No word-boundary or description matching.

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

Global cap on unique accepted lots across the run, after title filtering and deduplication. Default 10; 1–1000. Zero/unlimited is unsupported. Discovery can stop earlier at maxPages or source exhaustion.

## `maxPages` (type: `integer`):

Discovery-only request cap, 1–100 pages of up to 50 source lots each. Default 10. Ignored when supplied URLs are nonempty. This bounds scanned source lots, not accepted output; it does not promise exhaustive inventory.

## `includeDescriptions` (type: `boolean`):

Default true: discovery fetches each accepted lot detail and returns plain-text descriptions plus auction titles when available. False skips discovery detail requests and returns null for description and auctionTitle. Supplied URLs always require detail lookup; false suppresses only their description.

## Actor input object example

```json
{
  "lotUrls": [],
  "keyword": "",
  "maxItems": 10,
  "maxPages": 10,
  "includeDescriptions": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

Unique accepted Goldin lots.

## `summary` (type: `string`):

Counts and collection caps for this run.

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/goldin-auction-lots-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/goldin-auction-lots-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 '{
  "maxItems": 10
}' |
apify call automation-lab/goldin-auction-lots-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/goldin-auction-lots-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/yyhxcPpfUqy5zS5xv/builds/YfTeTbX9xPh0p2Fm0/openapi.json