# Courtyard.io Scraper | Cheap 1$/1k (`trev0n/courtyard-io-scraper`) Actor

Scrape Courtyard.io — the tokenized collectibles marketplace. Graded Pokémon & sports cards, packs, comics and coins with prices, PSA/CGC/BGS grades, fair-market-value estimates, deal scores and owner data. Filter by category, grader, grade, price and year, and run cheap incremental monitoring.

- **URL**: https://apify.com/trev0n/courtyard-io-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 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/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

## 🃏 Courtyard.io Scraper

🎯 **Extract every graded card, sealed pack, comic and coin from Courtyard.io — with live prices, PSA/CGC/BGS grades, fair-market-value estimates and deal scores — in seconds.**

Courtyard.io is the fastest-growing marketplace for tokenized physical collectibles: graded Pokémon and sports cards, sealed booster packs, graded comic books, coins and watches, all vaulted and insured. This scraper pulls the entire marketplace — asking prices, last sales, grading details, estimated market values, owner info and high-resolution slab images — into clean, structured data you can analyze, monitor or feed into your own tools.

### 🚀 What Does It Do?

This scraper automatically searches and browses the Courtyard.io marketplace and collects **structured, ready-to-use data** on every collectible asset it finds. No manual browsing needed — just set your filters and hit Start.

💡 **Two modes of operation:**

1. **🔍 Discovery Mode** — search by keywords (e.g. "Charizard", "Michael Jordan") and/or filter by category, grading company, grade, language, set, year and price range
2. **📋 Direct URL Mode** — paste specific asset URLs (https://courtyard.io/asset/…) and get their full data instantly

### 👥 Who Is This For?

| 🏢 Use Case                      | 💬 How It Helps                                                                                                                         |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| 📊 **Card investors & flippers** | Spot assets priced under their estimated market value before anyone else — the deal score and price-vs-value fields do the math for you |
| 🔎 **Collectors**                | Track every listing of the cards you hunt — get notified the moment a new copy appears or a price drops                                 |
| 📈 **Market analysts**           | Build price datasets across 300,000+ graded collectibles: grade premiums, population trends, prices by set and year                     |
| 🤖 **App & tool builders**       | Feed clean marketplace data into price trackers, Discord bots, portfolio dashboards or AI agents                                        |
| 🏪 **Card shops & dealers**      | Benchmark your inventory pricing against a live marketplace with fair-market-value estimates                                            |

### ✨ Features

- 🃏 **Full marketplace coverage** — graded cards, sealed booster packs, raw cards, comics, coins and watches — 300,000+ assets
- 💰 **Complete pricing picture** — asking price, estimated market value, confidence level, deal score and price-vs-value percentage on every asset
- 🏅 **Grading data** — grading company (PSA, CGC, BGS, SGC and more), grade label, numeric grade and certification number
- 🔍 **Keyword search** — find assets by player, character, set or any phrase, exactly like the site's search
- 🎛️ **Smart Filters** — category, product type, grader, exact grade or minimum grade, language, set, tags, year range and price range
- 💎 **Deal hunting mode** — keep only assets priced under a chosen percentage of their estimated value, or sort by best deals
- 📊 **Live sales feed** — sort by "recently sold" to turn any run into a feed of completed sales
- 👤 **Ownership & provenance** — owner username, wallet address and owned-since date on every asset
- 🔄 **Incremental monitoring** — schedule recurring runs that emit only NEW / UPDATED / REAPPEARED assets and pay only for changes (saves 80–95% on daily monitoring)
- 🔔 **Instant notifications** — get new finds pushed to Telegram, Discord, Slack or any webhook
- ⚡ **Fast & Scalable** — thousands of assets per minute, and no artificial result caps — the scraper automatically digs past the site's 5,000-per-search ceiling
- 🧹 **Deduplication** — every asset appears exactly once per run
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                              | What It Does                                                                                           |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------ |
| 🔍 **Search keywords**              | Find assets by any phrase — player, character, set, promo name                                         |
| 🗂️ **Sort by**                      | Recently listed, recently sold (sales feed!), recently added, price low→high / high→low, or best deals |
| 🃏 **Categories**                   | Pokémon, Baseball, Basketball, Football, One Piece, Magic The Gathering, Yu-Gi-Oh! and 20+ more        |
| 📦 **Collections**                  | Graded cards, sealed booster packs, raw cards, comic books, coins, watches                             |
| 🏅 **Grading companies**            | PSA, CGC, BGS, SGC, PCGS, NGC and more                                                                 |
| 💯 **Exact grades / Minimum grade** | Pin exact grade labels or set a numeric floor (e.g. only 9+)                                           |
| 🌍 **Card languages**               | English, Japanese, Chinese, Korean and more                                                            |
| 🎴 **Sets & Tags**                  | Narrow down to exact sets or marketplace tags (e.g. "Charizard" + "Holo")                              |
| 📅 **Year range**                   | Only assets released between chosen years                                                              |
| 💵 **Price range (USD)**            | Lower and upper bounds on the asking price                                                             |
| 🛒 **Listed for sale only**         | Include or exclude vaulted assets that aren't currently for sale                                       |
| 💎 **Max price vs. value (%)**      | Deal hunting — keep only assets priced under X% of their estimated value                               |
| 👤 **Owner**                        | Only assets owned by a given username or wallet                                                        |
| 🔢 **Max Results**                  | Control how many items to extract per run                                                              |
| 🔗 **Direct URLs**                  | Optionally provide specific asset URLs to scrape                                                       |

### 📦 What You Get (Output Fields)

Every asset includes:

#### Asset Identity

| Field      | Example                                                                           |
| ---------- | --------------------------------------------------------------------------------- |
| assetId    | `63c6401c0b8f840c51baabb735d5342f55320e531ac2376b43e193e43b779ff8`                |
| title      | `2017 Black Star Promos #SWSH050 Charizard V - Holo (CGC 8.5 NM-MT+)`             |
| url        | `https://www.courtyard.io/asset/63c6401c…`                                        |
| collection | `Graded Cards`                                                                    |
| category   | `Pokémon`                                                                         |
| set        | `Black Star Promos - Sword & Shield`                                              |
| year       | `2017`                                                                            |
| cardNumber | `SWSH050`                                                                         |
| variant    | `Holo Champion's Path Elite Trainer Box`                                          |
| subject    | `Charizard V`                                                                     |
| language   | `English`                                                                         |
| imageUrl   | `https://static.courtyard.io/graded-cards-renders/CGC%203831074181/nft_image.jpg` |

#### Grading

| Field        | Example      |
| ------------ | ------------ |
| grader       | `CGC`        |
| grade        | `8.5 NM-MT+` |
| gradeNumeric | `8.5`        |
| certNumber   | `3831074181` |

#### Pricing & Valuation

| Field                    | Example                |
| ------------------------ | ---------------------- |
| isListed                 | `true`                 |
| priceUsd                 | `22.5`                 |
| priceCurrency            | `USDC`                 |
| estimatedValueUsd        | `18.7`                 |
| estimatedValueConfidence | `5`                    |
| dealScore                | `-20.32`               |
| priceVsValuePct          | `120`                  |
| listingExpiration        | `2026-07-13T11:37:10Z` |
| lastSaleDate             | `2026-05-28T22:30:08Z` |

#### Ownership & Provenance

| Field         | Example                                      |
| ------------- | -------------------------------------------- |
| ownerUsername | `simplecolossus3483`                         |
| ownerAddress  | `0x6bb54a0192874DcfbB3780D6081f47B1afd2C0f3` |
| ownedSince    | `2026-05-28T22:30:08.000Z`                   |
| chain         | `polygon`                                    |
| mintedAt      | `2026-05-28T22:30:08Z`                       |
| listedAt      | `2026-07-06T11:37:17Z`                       |

### 📊 Example Output

```json
{
    "assetId": "63c6401c0b8f840c51baabb735d5342f55320e531ac2376b43e193e43b779ff8",
    "title": "2017 Black Star Promos - Sword & Shield #SWSH050 Charizard V - Holo Champion's Path Elite Trainer Box (CGC 8.5 NM-MT+)",
    "url": "https://www.courtyard.io/asset/63c6401c0b8f840c51baabb735d5342f55320e531ac2376b43e193e43b779ff8",
    "collection": "Graded Cards",
    "category": "Pokémon",
    "set": "Black Star Promos - Sword & Shield",
    "year": 2017,
    "cardNumber": "SWSH050",
    "variant": "Holo Champion's Path Elite Trainer Box",
    "subject": "Charizard V",
    "language": "English",
    "grader": "CGC",
    "grade": "8.5 NM-MT+",
    "gradeNumeric": 8.5,
    "certNumber": "3831074181",
    "isListed": true,
    "priceUsd": 22.5,
    "priceCurrency": "USDC",
    "estimatedValueUsd": 18.7,
    "estimatedValueSource": "pricing_model",
    "estimatedValueConfidence": 5,
    "dealScore": -20.32,
    "priceVsValuePct": 120,
    "listingExpiration": "2026-07-13T11:37:10Z",
    "ownerUsername": "simplecolossus3483",
    "ownerAddress": "0x6bb54a0192874DcfbB3780D6081f47B1afd2C0f3",
    "ownedSince": "2026-05-28T22:30:08.000Z",
    "chain": "polygon",
    "imageUrl": "https://static.courtyard.io/graded-cards-renders/CGC%203831074181/nft_image.jpg",
    "tags": ["Pokémon", "Charizard V", "English", "Holo"],
    "listedAt": "2026-07-06T11:37:17Z",
    "lastSaleDate": "2026-05-28T22:30:08Z",
    "scrapedAt": "2026-07-06T12:09:37.022Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **5 ready-made table views** to quickly browse your results:

| View                        | What It Shows                                                              |
| --------------------------- | -------------------------------------------------------------------------- |
| 📊 **Overview**             | Image, title, price, estimated value, grade and category at a glance       |
| 💎 **Deals**                | Price vs. estimated value, deal score and confidence — sorted deal hunting |
| 🔄 **Monitoring**           | What changed since the last run — new, updated and reappeared assets       |
| 🏅 **Grading & Provenance** | Certification numbers, owners, wallets and mint dates                      |
| 📋 **Full Details**         | Every single field — the complete dataset                                  |

### ❓ FAQ

**🤔 How is this different from browsing Courtyard.io myself?**
You get the entire marketplace as structured data in one run — filter, sort and analyze 300,000+ assets in Excel or your own tools instead of clicking through pages. Plus monitoring mode watches it for you around the clock.

**🤔 Can I track price drops and new listings automatically?**
Yes — turn on incremental monitoring and schedule the scraper. Each run emits only what changed (new listings, price changes, sales), and can ping you on Telegram, Discord, Slack or any webhook.

**🤔 Can I get sold prices, not just asking prices?**
Yes — set "Sort by" to **Recently sold** and every run becomes a feed of the latest completed sales, including the sale date and last price.

**🤔 Is there a limit on how many assets I can extract?**
No — the scraper automatically works past the site's 5,000-per-search ceiling, so even a full-marketplace export is possible.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh data, run daily or weekly. You can schedule automatic runs on Apify with just a few clicks — with monitoring mode on, recurring runs cost a fraction of a full scrape.

**🤔 Does it work with proxies?**
It works reliably without any proxy out of the box. If you ever need one, the scraper supports Apify's built-in proxy service with a single toggle.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (specific cert-number lists, seller watchlists, deal-alert thresholds)
- 📊 Extra data fields or custom output formats
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping with automatic deduplication
- 🌐 Scraping from other collectibles marketplaces alongside Courtyard.io

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects **only publicly available information** from Courtyard.io. It does not access private data, bypass authentication, or interfere with the marketplace's operation. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

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

What to search for (e.g. "Charizard", "Michael Jordan", "1st Edition"). Leave empty to browse by filters only.

## `sortBy` (type: `string`):

Ordering of results. "Recently sold" turns the run into a live sales feed; "Best deals" surfaces assets priced furthest under their estimated value.

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

Limit results to one or more categories (sport / game / franchise).

## `collections` (type: `array`):

Limit results to one or more product types.

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

Only assets graded by these companies.

## `grades` (type: `array`):

Only assets with these exact grade labels (e.g. "10 GEM MT", "9.5", "8.5 NM-MT+"). For a numeric threshold use "Minimum grade" below instead.

## `gradeMin` (type: `integer`):

Keep only assets graded at least this number (1–10). Assets without a numeric grade are dropped when set.

## `languages` (type: `array`):

Only cards printed in these languages.

## `sets` (type: `array`):

Only assets from these exact sets (e.g. "Base Set", "Black Star Promos - Sword & Shield").

## `tags` (type: `array`):

Narrow results by marketplace tags — every tag must match (e.g. "Charizard" + "Holo").

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

Earliest release year (0 = no limit).

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

Latest release year (0 = no limit).

## `priceMinUsd` (type: `integer`):

Lower bound of the asking price, in US dollars.

## `priceMaxUsd` (type: `integer`):

Upper bound of the asking price, in US dollars (0 = no limit).

## `listedOnly` (type: `boolean`):

Only assets that currently have an asking price. Turn off to also include vaulted assets that aren't for sale.

## `maxPriceVsValuePct` (type: `integer`):

Deal hunting: keep only assets whose asking price is at most this percentage of their estimated market value (e.g. 80 = priced at least 20% under value; 0 = off).

## `ownerFilter` (type: `string`):

Keep only assets owned by this user — a Courtyard username or a wallet address.

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

Optional courtyard.io asset URLs (https://courtyard.io/asset/…) or marketplace URLs to scrape directly instead of (or alongside) a keyword search.

## `maxResults` (type: `integer`):

Maximum number of assets to collect (0 = unlimited — the scraper automatically works past the site's 5,000-per-search ceiling).

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

Cap on result pages to fetch per search (0 = no cap; 100 results per page).

## `includeKeywords` (type: `array`):

Keep only assets whose title/set/tags contain at least one of these terms.

## `excludeKeywords` (type: `array`):

Drop assets whose title/set/tags contain any of these terms.

## `compact` (type: `boolean`):

Output only the core fields — handy for AI workflows.

## `excludeEmptyFields` (type: `boolean`):

Omit null / empty fields from each record.

## `incrementalMode` (type: `boolean`):

Track state across runs and emit only NEW / UPDATED / REAPPEARED assets (price changes, re-lists, sales). The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring.

## `stateKey` (type: `string`):

Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically.

## `emitUnchanged` (type: `boolean`):

Also output assets whose market state didn't change since the last run.

## `emitExpired` (type: `boolean`):

Also output a record for assets that disappeared since the last run (changeType = EXPIRED — usually sold or delisted).

## `skipReposts` (type: `boolean`):

Drop new assets detected as reposts of a recently expired one (same market state, new id).

## `notifyOnlyChanges` (type: `boolean`):

Only send notifications when there are new/updated assets.

## `notificationLimit` (type: `integer`):

Maximum number of assets listed in a single notification message.

## `includeRunSummary` (type: `boolean`):

Attach the run summary object to the generic webhook payload.

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

Generic webhook to POST results to (JSON).

## `telegramBotToken` (type: `string`):

Telegram bot token for notifications.

## `telegramChatId` (type: `string`):

Telegram chat id to send notifications to.

## `discordWebhookUrl` (type: `string`):

Discord channel webhook for notifications.

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

Slack incoming webhook for notifications.

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

Proxy settings. The data source works reliably without any proxy, so none is used by default — turn one on only if your runs ever get rate-limited.

## Actor input object example

```json
{
  "query": "Charizard",
  "sortBy": "recentlyListed",
  "gradeMin": 0,
  "yearMin": 0,
  "yearMax": 0,
  "priceMinUsd": 0,
  "priceMaxUsd": 0,
  "listedOnly": true,
  "maxPriceVsValuePct": 0,
  "maxResults": 100,
  "maxPages": 0,
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "notifyOnlyChanges": true,
  "notificationLimit": 10,
  "includeRunSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "query": "Charizard"
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/courtyard-io-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 = { "query": "Charizard" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Courtyard.io Scraper | Cheap 1$/1k",
        "description": "Scrape Courtyard.io — the tokenized collectibles marketplace. Graded Pokémon & sports cards, packs, comics and coins with prices, PSA/CGC/BGS grades, fair-market-value estimates, deal scores and owner data. Filter by category, grader, grade, price and year, and run cheap incremental monitoring.",
        "version": "1.0",
        "x-build-id": "5njTEcHKmMbwaV2al"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~courtyard-io-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-courtyard-io-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/trev0n~courtyard-io-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-courtyard-io-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/trev0n~courtyard-io-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-courtyard-io-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",
                "properties": {
                    "query": {
                        "title": "Search keywords",
                        "type": "string",
                        "description": "What to search for (e.g. \"Charizard\", \"Michael Jordan\", \"1st Edition\"). Leave empty to browse by filters only."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "recentlyListed",
                            "recentlySold",
                            "recentlyAdded",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "bestDeals"
                        ],
                        "type": "string",
                        "description": "Ordering of results. \"Recently sold\" turns the run into a live sales feed; \"Best deals\" surfaces assets priced furthest under their estimated value.",
                        "default": "recentlyListed"
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Limit results to one or more categories (sport / game / franchise).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Pokémon",
                                "Baseball",
                                "Basketball",
                                "Football",
                                "One Piece",
                                "Magic The Gathering",
                                "Soccer",
                                "Hockey",
                                "Marvel Comic",
                                "Marvel",
                                "VeeFriends",
                                "D.C. Comic",
                                "Independent Comic",
                                "Disney",
                                "Formula 1",
                                "SLAM Magazine",
                                "Yu-Gi-Oh!",
                                "Star Wars",
                                "Boxing",
                                "Weiss Schwarz",
                                "Wrestling",
                                "Golf",
                                "Racing",
                                "Tennis",
                                "Watches",
                                "MetaZoo",
                                "Dragon Ball",
                                "Nintendo",
                                "Other"
                            ]
                        }
                    },
                    "collections": {
                        "title": "Collections",
                        "type": "array",
                        "description": "Limit results to one or more product types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Graded Cards",
                                "Ungraded Booster Packs",
                                "Raw Cards",
                                "Graded Comic Books",
                                "Graded Coins",
                                "Watches"
                            ]
                        }
                    },
                    "graders": {
                        "title": "Grading companies",
                        "type": "array",
                        "description": "Only assets graded by these companies.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PSA",
                                "CGC",
                                "CGC-COMIC",
                                "BGS",
                                "SGC",
                                "CSG",
                                "PCGS",
                                "NGC",
                                "AGS",
                                "GMA",
                                "HGA",
                                "BCCG",
                                "BVG",
                                "ISA"
                            ]
                        }
                    },
                    "grades": {
                        "title": "Exact grades",
                        "type": "array",
                        "description": "Only assets with these exact grade labels (e.g. \"10 GEM MT\", \"9.5\", \"8.5 NM-MT+\"). For a numeric threshold use \"Minimum grade\" below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gradeMin": {
                        "title": "Minimum grade",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Keep only assets graded at least this number (1–10). Assets without a numeric grade are dropped when set.",
                        "default": 0
                    },
                    "languages": {
                        "title": "Card languages",
                        "type": "array",
                        "description": "Only cards printed in these languages.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "English",
                                "Japanese",
                                "Chinese",
                                "Korean",
                                "Spanish",
                                "Indonesian",
                                "German",
                                "Italian",
                                "French",
                                "Portuguese"
                            ]
                        }
                    },
                    "sets": {
                        "title": "Sets",
                        "type": "array",
                        "description": "Only assets from these exact sets (e.g. \"Base Set\", \"Black Star Promos - Sword & Shield\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "Narrow results by marketplace tags — every tag must match (e.g. \"Charizard\" + \"Holo\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "yearMin": {
                        "title": "Year from",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Earliest release year (0 = no limit).",
                        "default": 0
                    },
                    "yearMax": {
                        "title": "Year to",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Latest release year (0 = no limit).",
                        "default": 0
                    },
                    "priceMinUsd": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound of the asking price, in US dollars.",
                        "default": 0
                    },
                    "priceMaxUsd": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound of the asking price, in US dollars (0 = no limit).",
                        "default": 0
                    },
                    "listedOnly": {
                        "title": "Listed for sale only",
                        "type": "boolean",
                        "description": "Only assets that currently have an asking price. Turn off to also include vaulted assets that aren't for sale.",
                        "default": true
                    },
                    "maxPriceVsValuePct": {
                        "title": "Max price vs. value (%)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Deal hunting: keep only assets whose asking price is at most this percentage of their estimated market value (e.g. 80 = priced at least 20% under value; 0 = off).",
                        "default": 0
                    },
                    "ownerFilter": {
                        "title": "Owner",
                        "type": "string",
                        "description": "Keep only assets owned by this user — a Courtyard username or a wallet address."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional courtyard.io asset URLs (https://courtyard.io/asset/…) or marketplace URLs to scrape directly instead of (or alongside) a keyword search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of assets to collect (0 = unlimited — the scraper automatically works past the site's 5,000-per-search ceiling).",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on result pages to fetch per search (0 = no cap; 100 results per page).",
                        "default": 0
                    },
                    "includeKeywords": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "Keep only assets whose title/set/tags contain at least one of these terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "Drop assets whose title/set/tags contain any of these terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "compact": {
                        "title": "Compact output",
                        "type": "boolean",
                        "description": "Output only the core fields — handy for AI workflows.",
                        "default": false
                    },
                    "excludeEmptyFields": {
                        "title": "Exclude empty fields",
                        "type": "boolean",
                        "description": "Omit null / empty fields from each record.",
                        "default": false
                    },
                    "incrementalMode": {
                        "title": "Incremental monitoring mode",
                        "type": "boolean",
                        "description": "Track state across runs and emit only NEW / UPDATED / REAPPEARED assets (price changes, re-lists, sales). The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically."
                    },
                    "emitUnchanged": {
                        "title": "Emit unchanged assets",
                        "type": "boolean",
                        "description": "Also output assets whose market state didn't change since the last run.",
                        "default": false
                    },
                    "emitExpired": {
                        "title": "Emit expired assets",
                        "type": "boolean",
                        "description": "Also output a record for assets that disappeared since the last run (changeType = EXPIRED — usually sold or delisted).",
                        "default": false
                    },
                    "skipReposts": {
                        "title": "Skip reposts",
                        "type": "boolean",
                        "description": "Drop new assets detected as reposts of a recently expired one (same market state, new id).",
                        "default": false
                    },
                    "notifyOnlyChanges": {
                        "title": "Notify only on changes",
                        "type": "boolean",
                        "description": "Only send notifications when there are new/updated assets.",
                        "default": true
                    },
                    "notificationLimit": {
                        "title": "Assets per notification",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of assets listed in a single notification message.",
                        "default": 10
                    },
                    "includeRunSummary": {
                        "title": "Include run summary in webhook",
                        "type": "boolean",
                        "description": "Attach the run summary object to the generic webhook payload.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Generic webhook to POST results to (JSON)."
                    },
                    "telegramBotToken": {
                        "title": "Telegram bot token",
                        "type": "string",
                        "description": "Telegram bot token for notifications."
                    },
                    "telegramChatId": {
                        "title": "Telegram chat ID",
                        "type": "string",
                        "description": "Telegram chat id to send notifications to."
                    },
                    "discordWebhookUrl": {
                        "title": "Discord webhook URL",
                        "type": "string",
                        "description": "Discord channel webhook for notifications."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming webhook for notifications."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The data source works reliably without any proxy, so none is used by default — turn one on only if your runs ever get rate-limited.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
