# Goldin Auctions Scraper — Sports Cards, TCG & Sold Comps (`crawloop/goldin-scraper`) Actor

Scrape Goldin Auctions for live lots, sold comps, and Fixed Price marketplace. Get hammer price, buyer's premium, bid counts, Weekly/Elite tier, PSA/BGS/SGC grades, and images as JSON — dealers, consignors, and pricing apps.

- **URL**: https://apify.com/crawloop/goldin-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Sports
- **Features:** Limited permissions
- **Stats:** 10 total users, 7 monthly users, 99.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.69 / 1,000 lot results

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 Auctions Scraper — Sports Cards, TCG & Sold Comps

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Goldin or eBay or its affiliates. Data is read from publicly accessible pages only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

**Goldin Auctions scraper** for high-end **sports cards**, **TCG / Pokémon**, and memorabilia. Pull **live lots**, **sold comps** (past auction results), and Fixed Price marketplace listings into JSON — hammer price, buyer's premium, bid counts, Weekly / Elite tier, and PSA / BGS / SGC / CGC grades. Works as a **Goldin API alternative** via HTTP search (Python / Node.js / MCP) — no headless browser.

### Collectibles suite

| Actor | Role |
| --- | --- |
| [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) | US TCG seller listings and shops |
| [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper) | EU TCG seller offers and shops |
| [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) | Weekly / Premier auctions, Buy Now, sold comps |
| Goldin Auctions Scraper ◄── you are here | High-end auction live lots & sold comps |
| [Heritage Auctions Scraper](https://apify.com/crawloop/heritage-auctions-scraper) | Heritage live bids and archive cards |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | Set-level PSA pop census and gem rate |
| [Whatnot Listings Scraper](https://apify.com/crawloop/whatnot-listings-scraper) | Live-commerce listings and shops |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | Guide prices for games, TCG, and comics |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Marketplace completed sales |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live asking prices |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Aggregate comps & pricing stats |

**Suite next step:** after Goldin sold comps, run [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) for weekly-volume hammer on the same titles, then [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) for gem rate vs elite price. Volume marketplace still goes to [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper).

### When to use

- Pull **Goldin sold prices** from Weekly / Elite auctions to set reserves and consignment floors
- Monitor **live Goldin lots** by player, set, or grader (PSA 10, BGS Black Label)
- Browse **Fixed Price / marketplace** buy-it-now inventory
- Resolve specific lot URLs into structured rows for sheets or warehouses
- Feed apps that need hammer + buyer's premium (true all-in buyer cost)

**When not to use:** Fanatics Collect weekly volume auctions — use [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper). Low-volume eBay-only comps — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper). Live TCG seller books — use [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) or [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper). Lot-detail fields gated behind login are not scraped.

### Key features

- **Four modes** — `live`, `sold`, `marketplace`, `lot_urls` (+ `auto`)
- **Auction tiers** — Weekly, Elite, Thematic, Fixed_Price
- **Sold archive** — hundreds of thousands of `Completed_Sold` comps
- **Buyer's premium aware** — `buyersPremiumPct` + `priceWithPremium` on every row
- **Grade parsing** — PSA / BGS / SGC / CGC / HGA / TAG from titles → label + numeric
- **Title fields** — card year, rookie, autograph, and serial (`12/99`, `/99`, `1/1`) parsed from the lot title. Description text is not in the search response
- **Keyword + filters** — sport, category, grader, year range, price range, auction ID
- **Sold-date window** — `soldAfter` / `soldBefore` on completed lots. This endpoint ignores sort and is not date-ordered, so the Actor keeps scanning up to `maxScan`
- **HTTP-first** — `curl_cffi` Chrome TLS against Goldin's lots search API; retries when search returns 503; proxy optional

### Input

| Field | Description |
| --- | --- |
| `mode` | `live` / `sold` / `marketplace` / `lot_urls` / `auto` |
| `searchQueries` | Keywords (player, set, card). Empty = browse all in mode |
| `startUrls` | Lot URLs or slugs (`lot_urls` mode) |
| `auctionType` | `All` / `Weekly` / `Elite` / `Thematic` / `Fixed_Price` |
| `auctionId` | Optional parent auction UUID |
| `soldOnly` | Force sold archive even outside `sold` mode |
| `category` / `categories` | Category facet; single field and list are combined |
| `sport` / `sports` | Sport facet; single field and list are combined |
| `grader` / `graders` | PSA/BGS/… A lot matches any selected grader |
| `grade` | Grade substring (e.g. `10`, `GEM`) |
| `minGrade` / `maxGrade` | Numeric grade window. Lots with no numeric grade are dropped when either is set |
| `yearMin` / `yearMax` | Card year, sent to Goldin as `yearRange` |
| `soldAfter` / `soldBefore` | Inclusive sale dates (`YYYY-MM-DD` or `30 days`) on sold/completed lots only |
| `rookiesOnly` / `autographedOnly` | Title flags (Rookie / RC / 1st Bowman / Bowman 1st; Auto / Signed / Signature) |
| `priceMin` / `priceMax` | USD price window. Sent to Goldin as `priceRange` with only the sides you set. Positive prices outside the window are dropped. A lot still at $0 (no bids) is kept only when `priceMin` is empty or 0. That scan counts toward `maxScan` |
| `maxScan` | Raw hits scanned per query when a client-side filter is on, including the price window (default 2000) |
| `maxItems` | Saved rows (`0` = unlimited). Does not cap the raw scan |
| `proxyConfiguration` | Optional; default off |

There is no sort option. Goldin's lots search ignores `sortOrder` and does not return description text.

#### Example — Goldin sold comps (sports cards)

```json
{
  "mode": "sold",
  "searchQueries": ["charizard psa 10"],
  "auctionType": "Elite",
  "maxItems": 50
}
```

#### Example — 1986–87 Jordan rookies, PSA 8–10, sold in 2025

Sold comps for 1986–87 Jordan rookies graded PSA 8 through 10 that closed in 2025. Year is filtered on Goldin's side. Sale date, rookie, and grade range are applied while scanning (`maxScan`). `categories`, `sports`, and `autographedOnly` are included so every added filter is in one input.

```json
{
  "mode": "sold",
  "searchQueries": ["michael jordan rookie"],
  "soldAfter": "2025-01-01",
  "soldBefore": "2025-12-31",
  "maxScan": 2000,
  "yearMin": 1986,
  "yearMax": 1987,
  "grader": "PSA",
  "graders": ["PSA"],
  "category": "Sport",
  "categories": ["Sport"],
  "sport": "Basketball",
  "sports": ["Basketball"],
  "rookiesOnly": true,
  "autographedOnly": false,
  "minGrade": 8,
  "maxGrade": 10,
  "maxItems": 100
}
```

#### Example — live Weekly lots

```json
{
  "mode": "live",
  "auctionType": "Weekly",
  "grader": "PSA",
  "maxItems": 100
}
```

#### Example — marketplace Fixed Price

```json
{
  "mode": "marketplace",
  "searchQueries": ["michael jordan"],
  "maxItems": 50
}
```

#### Example — specific lot URLs

```json
{
  "mode": "lot_urls",
  "startUrls": [
    { "url": "https://goldin.co/item/1999-pokemon-base-set-holo-4-charizard-psa-mint-9fcmjr" }
  ]
}
```

### Monitor new lots, price drops and bids

Schedule this Actor to watch a saved search and get **only deltas**: new lots, price drops, and bid increases since the last run. Turn on `monitorMode`, pick a distinct `monitorStoreName` per watch, and use the same keywords and filters each time.

The **first run is the baseline**: it still emits rows (up to `maxItems`) while remembering every scanned lot’s price and bid count. Later runs skip unchanged lots and charge only when something changed. `monitorMaxScan` controls how deep each run reads; `maxItems` caps how many changed rows are pushed per run.

```json
{
  "mode": "live",
  "searchQueries": ["charizard psa 10"],
  "monitorMode": true,
  "monitorStoreName": "goldin-charizard-psa10",
  "maxItems": 50,
  "monitorMaxScan": 1000
}
```

Tip: pair `monitorMode` with an **Apify Schedule** (hourly or daily) so you get a small dataset of fresh activity without re-scraping the full catalog.

### Output

| Field | Description |
| --- | --- |
| `lotId` / `lotNumber` / `metaSlug` / `url` | Identifiers & page URL |
| `title` / `status` | Title and Live / Completed_Sold / … |
| `auctionId` / `auctionType` | Parent auction + tier |
| `grader` / `grade` / `gradeNumeric` | Parsed grading |
| `year` | First card year in the title (`1986-87` → `1986`) |
| `isRookie` / `isAutographed` | Rookie and autograph flags from the title |
| `serialNumber` / `serialLimit` | Print run (`12/99` → 12 and 99; `/99` sets the limit only) |
| `itemType` / `companyId` | Present when the search hit includes them |
| `allowOffers` / `vaultable` | Listing flags when present |
| `currentPrice` / `finalPrice` / `minBidPrice` | USD prices |
| `buyersPremiumPct` / `priceWithPremium` | Premium % and all-in cost |
| `reserveAmount` / `reserveMet` / `bidCount` | Reserve & bidding |
| `startAt` / `endAt` / `soldAt` | Timestamps |
| `primaryImageUrl` / `imageUrls` | CloudFront images |
| `searchQuery` / `mode` / `scrapedAt` | Run metadata |

#### Sample record

```json
{
  "lotId": "202607-2314-0801-5f728d9d-0d42-4245-9805-84d252329706",
  "title": "2009-10 Topps Chrome Refractor #101 Stephen Curry Rookie Card (#071/500) - BGS GEM MINT 9.5",
  "status": "Live",
  "auctionType": "Elite",
  "grader": "BGS",
  "grade": "BGS GEM MINT 9.5",
  "gradeNumeric": 9.5,
  "year": 2009,
  "isRookie": true,
  "isAutographed": false,
  "serialNumber": 71,
  "serialLimit": 500,
  "currentPrice": 34000,
  "buyersPremiumPct": 22,
  "priceWithPremium": 41480,
  "bidCount": 23,
  "currency": "USD",
  "url": "https://goldin.co/item/2009-10-topps-chrome-refractor-101-stephen-curry-rookie-card-071-500-bgzew9",
  "primaryImageUrl": "https://d2tt46f3mh26nl.cloudfront.net/public/Lots/example/image@1x"
}
```

### Use cases

- **Consignment pricing** — Elite sold comps before setting reserves
- **Dealer watchlists** — Weekly live lots filtered by PSA / BGS
- **High-end vs eBay** — Goldin hammer vs marketplace sold volume
- **TCG / Pokémon comps** — sold archive search by set and grade
- **Marketplace scan** — Fixed Price buy-now lots
- **Automation / MCP** — scheduled sold pulls into sheets or warehouses

### Integration examples

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/goldin-scraper').call({
  mode: 'sold',
  searchQueries: ['jordan psa 10'],
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("crawloop/goldin-scraper").call(run_input={
    "mode": "live",
    "auctionType": "Weekly",
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item.get("currentPrice"))
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~goldin-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"sold","searchQueries":["charizard"],"maxItems":20}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).
Connect your Apify account, then call this Actor by its Store ID / name.

Example prompts:

- "Run Goldin Auctions Scraper in sold mode for 'Shohei Ohtani PSA 10' and return the top 20 comps as JSON"
- "Scrape live Weekly Goldin lots graded PSA and summarize average bid and buyer's premium"
- "Chain Goldin sold comps then Fanatics Collect Scraper for the same Charizard titles"

### FAQ

**Is this a Goldin API alternative?**\
Yes for public lot search: live, sold, and marketplace rows via Goldin's search endpoint — no official developer API key required.

**Does the Goldin scraper need a proxy?**\
Usually no. Enable Apify Proxy only if you hit rate limits.

**What is `priceWithPremium`?**\
Goldin adds a buyer's premium on top of hammer (often ~22%). `priceWithPremium = currentPrice × (1 + buyersPremiumPct/100)`.

**Can I scrape all Goldin sold results?**\
Yes — `mode: sold` with empty `searchQueries` and `maxItems: 0`. The archive is large; use keywords and PPE limits for focused comps.

**How do I get sports card or Pokémon comps?**\
Use `mode: sold` with queries like `mantle psa 8` or `charizard psa 10`, optionally `auctionType: Elite` or `grader: PSA`.

**Why is grade sometimes null?**\
Grades are parsed from titles. Ungraded memorabilia may not match; use `grader` when titles include PSA/BGS/etc.

**Can I filter Goldin sold prices by date?**\
Yes. Set `soldAfter` and `soldBefore` to `YYYY-MM-DD` (or a relative window such as `30 days`). Both days are inclusive. The filter uses `endAt` on sold/completed lots and leaves live lots unchanged. Goldin has no sold-date parameter and does not return this endpoint in date order, so there is no sort option — the Actor keeps scanning up to `maxScan` raw hits per query and keeps the matches. `maxItems` still caps saved rows.

**Can I filter by card year / rookie / autograph?**\
`yearMin` and `yearMax` are sent as a server-side year range (`1986`–`1987` for a 1986-87 card). `rookiesOnly` matches Rookie, a standalone `RC`, 1st Bowman, First Bowman, and Bowman 1st. `autographedOnly` matches Auto, Autograph, Signed, and Signature, and does not match Automobile. `minGrade` / `maxGrade` use the numeric grade parsed from the title. Description text is not included in search results, so these flags come from the title only.

**What happens when Goldin search is down?**\
The lots search sometimes returns HTTP 503 `search_unavailable` for several seconds. The Actor retries 429 and 5xx responses and network errors with backoff (8 attempts by default, waits about 1, 2, 4, 8, 15, 20, and 20 seconds). If a later page still fails after some rows were saved, that query stops, the next query continues, and the run finishes succeeded with the status `Goldin search was temporarily unavailable — returned N partial results`. If nothing could be fetched, the run fails with `Goldin search is temporarily unavailable (HTTP 503). Please retry in a few minutes.` When that request included filters, the message also says `If this persists, a filter combination may be unsupported by Goldin search.` A monitor run that was cut short does not treat unseen lots as removed and does not replace the baseline.

### Related Actors

| Actor | Role |
| --- | --- |
| Goldin Auctions Scraper ◄── you are here | High-end sports cards / TCG hammer + sold |
| [Heritage Auctions Scraper](https://apify.com/crawloop/heritage-auctions-scraper) | Heritage live bids and archive cards |
| [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) | Weekly / Premier auctions + sold |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | PSA pop census and gem rate |
| [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) | US TCG listings and shops |
| [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper) | EU TCG listings and shops |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Marketplace sold prices |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live asking prices |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Aggregated sold stats |

# Actor input Schema

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

What to scrape. live = active auction lots; sold = completed sales archive (comps); marketplace = Fixed Price / private sales; lot_urls = resolve specific lot URLs; auto picks from inputs.

## `searchQueries` (type: `array`):

Keywords to search (player, set, card, grade). Leave empty to browse all lots in the selected mode. Each query runs separately.

## `startUrls` (type: `array`):

Goldin lot URLs or meta-slugs for lot_urls mode. Example: https://goldin.co/item/1999-pokemon-base-set-holo-4-charizard-psa-mint-9fcmjr

## `auctionType` (type: `string`):

Filter by Goldin auction tier. Marketplace mode forces Fixed_Price.

## `auctionId` (type: `string`):

Optional Goldin auction UUID to scope lots to one sale.

## `soldOnly` (type: `boolean`):

When true, only Completed_Sold lots (overrides live mode). Useful with marketplace or keyword search.

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

Optional Algolia category facet (e.g. Sport, Non-Sport). Combined with categories.

## `sport` (type: `string`):

Optional sport facet (e.g. Baseball, Basketball, Pokemon).

## `grader` (type: `string`):

Filter by grading company parsed from titles (and certification facet when available).

## `grade` (type: `string`):

Optional substring filter on parsed grade (e.g. 10, 9.5, GEM).

## `priceMin` (type: `number`):

Minimum USD price, sent as priceRange.min. 0 or empty = no floor. Lots still at $0 (no bids) are dropped when a minimum is set.

## `priceMax` (type: `number`):

Maximum USD price, sent as priceRange.max. 0 or empty = no ceiling.

## `soldAfter` (type: `string`):

Keep sold/completed lots whose sale date (end time) is on or after this day. YYYY-MM-DD or a relative date such as "30 days". Live lots are not filtered. Goldin does not sort by date, so the Actor scans up to maxScan raw hits per query.

## `soldBefore` (type: `string`):

Keep sold/completed lots whose sale date (end time) is on or before this day. YYYY-MM-DD or a relative date such as "30 days". Inclusive. Live lots are not filtered.

## `maxScan` (type: `integer`):

Max raw search hits scanned per query when a client-side filter is on (sold date, rookie, autograph, grade range, or price window). maxItems still caps saved rows.

## `yearMin` (type: `integer`):

Minimum card year, sent as yearRange.min. If year max is empty, the max is next calendar year.

## `yearMax` (type: `integer`):

Maximum card year, sent as yearRange.max. If year min is empty, the min is 1800.

## `graders` (type: `array`):

One or more graders. Combined with the single grader field. A lot matches if its title grader is any of these.

## `categories` (type: `array`):

One or more category facets. Combined with the single category field.

## `sports` (type: `array`):

One or more sport facets (e.g. Baseball, Basketball). Combined with the single sport field.

## `rookiesOnly` (type: `boolean`):

Keep lots whose title says Rookie, RC, 1st Bowman, or Bowman 1st. Applied after download.

## `autographedOnly` (type: `boolean`):

Keep lots whose title says Auto, Autograph, Signed, or Signature (not Automobile). Applied after download.

## `minGrade` (type: `number`):

Keep lots whose parsed gradeNumeric is at least this (e.g. 8). Lots with no numeric grade are dropped when min or max grade is set.

## `maxGrade` (type: `number`):

Keep lots whose parsed gradeNumeric is at most this (e.g. 10). Lots with no numeric grade are dropped when min or max grade is set.

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

Maximum lot records to output across all queries. 0 = unlimited. Does not cap raw hits scanned for client-side filters.

## `requestDelaySecs` (type: `number`):

Throttle between API calls.

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

On a schedule, push and charge only new lots, price drops and bid increases since the previous run. The first run builds a baseline and still returns rows.

## `monitorStoreName` (type: `string`):

Named key-value store for monitor state. Use a distinct name per watch or search you track.

## `resetMonitorState` (type: `boolean`):

Clear saved monitor state before this run (starts a fresh baseline).

## `monitorMaxScan` (type: `integer`):

How many lots to scan per monitor run. maxItems caps emitted/charged rows, not the scan depth.

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

Optional. Goldin search API usually works without a proxy. Enable Apify Proxy only if you hit rate limits.

## Actor input object example

```json
{
  "mode": "live",
  "searchQueries": [],
  "startUrls": [],
  "auctionType": "All",
  "auctionId": "",
  "soldOnly": false,
  "category": "",
  "sport": "",
  "grader": "",
  "grade": "",
  "priceMin": 0,
  "priceMax": 0,
  "soldAfter": "",
  "soldBefore": "",
  "maxScan": 2000,
  "categories": [],
  "sports": [],
  "rookiesOnly": false,
  "autographedOnly": false,
  "maxItems": 100,
  "requestDelaySecs": 0.12,
  "monitorMode": false,
  "monitorStoreName": "goldin-monitor",
  "resetMonitorState": false,
  "monitorMaxScan": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset 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 = {};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/goldin-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/TxObDOIid3xI9aZJl/builds/rV2YEhSrAmZ8MvDCU/openapi.json