# GemRate Card Grading Population & Sales Data Scraper (`amrameng/gemrate-scraper`) Actor Card-grading population data from GemRate — PSA, Beckett, SGC, CGC — plus eBay sales trends. Search cards and sets, pull set/player breakdowns, top cards, population trends, historical replays, and dashboard data. Pick an operation, get structured JSON. Read-only. - **URL**: https://apify.com/amrameng/gemrate-scraper.md - **Developed by:** [Amram Englander](https://apify.com/amrameng) (community) - **Categories:** E-commerce, Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $8.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. 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 ## GemRate Card Grading Population Scraper Pull **trading-card grading population data** from [GemRate](https://www.gemrate.com) — covering **PSA, Beckett (BGS), SGC, and CGC**. Search cards and sets, get **per-grader gem rates and population counts**, list every card in a set, **track population growth over time**, replay historical snapshots, rank the most-graded cards, and export the site's full cross-grader pop reports — all as clean, structured JSON. No login, no coding. > Looking for **eBay sales/price trends** instead? Use the companion **GemRate eBay Card Sales Trends Scraper**. ### What does the GemRate Card Grading Scraper do? GemRate is the trading-card industry's population-data hub: how many copies of a card exist at each grade, across each grading company. It has **no public API**, so this Actor wraps the data behind the GemRate web app and returns it as structured rows you can download or pipe anywhere. You pick one **operation** (search, set breakdown, top cards, population trend, pop reports, and more — 13 in total), fill in a few fields, and the Actor returns the matching data. It runs on the **Apify platform**, so you get a scheduler, a REST API, webhooks, integrations (Make, Zapier, Google Sheets, Slack), proxy rotation, and run monitoring out of the box. **No GemRate account is required** — the data is publicly accessible. ### Why use this scraper? - 📈 **Card investment & market research** — gem rates and populations are the _supply_ side of card value. Find the scarcest high-grade cards, spot over- or under-graded sets, and quantify true rarity before you buy or sell. - 🔢 **Population tracking** — watch a card's or set's graded population grow month over month to anticipate price moves and grading waves. - 🏆 **Top-cards & set intelligence** — pull the most-graded cards in any category, or every card in a set with its individual gem rate and recent growth. - 🃏 **Cross-grader comparison** — see PSA vs. BGS vs. SGC vs. CGC side by side for a single card, or across hundreds of iconic cards and sets at once. - ⚙️ **Automate it** — schedule runs to keep a population dataset fresh and feed it into a sheet, a database, a dashboard, or an alert. Useful for **card investors, dealers, breakers, set-registry collectors, marketplaces, pricing tools, and content creators** who need grading data programmatically. ### How to use it 1. Click **Try for free** / **Start**. 2. In the **Input** tab, choose an **Operation** (e.g. _Search cards by name_, _Top graded cards_, _Card population trend_). 3. Fill in the parameters that operation needs — every field's description notes which operations use it. 4. _(Optional)_ Add a text **filter** (contains) or a **limit**, and confirm the **proxy**. 5. Click **Save & Start**. When the run finishes, open the **Output / Storage** tab and download the data as **JSON, CSV, Excel, or HTML** — or pull it via the API. > 💡 New to GemRate IDs? Run **Search cards by name** first (e.g. `Michael Jordan`), copy a `gemrate_id` from the results, then run **Card grading details** with it for the full per-grader breakdown. ### What you can pull (operations) | Operation | What you get | Key parameters | | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | | **Search cards by name** | Up to 10 matching cards across all graders | `query` | | **Search sets by name** | Up to 10 matching sets | `query` | | **Card grading details** | Full per-grader grade breakdown for one card | `gemrateId` | | **Set breakdowns** | Every set for a grader / category / year, with gem rates | `grader`, `category`, `year` | | **Cards in a set** | Every card in a set with individual gem rates and growth | `grader`, `category`, `year`, `setName` | | **Top graded cards** | The Top 100 / 500 / 1000 most-graded cards | `grader`, `category`, `count` | | **Player / subject cards** | All graded cards for a player or character | `grader`, `category`, `playerName` | | **Card population trend** | A single card's graded population over time | `grader`, `category`, `year`, `setName`, `playerName` | | **Set population trend** | A whole set's graded population over time | `grader`, `category`, `year`, `setName` | | **Historical replay** | A set's grading data as it stood on a past date | `grader`, `category`, `year`, `setName`, `date` | | **Dashboard datasets** | GemRate homepage grading trends and stats | `dashboardDataset` (optional) | | **Iconic Tracker** | ~105 iconic cards with the site's fullest cross-grader breakdown (per-grader grade-by-grade pops, gem rates, percentiles, monthly trend, price links, rank) | — | | **Universal Pop Report** | ~391 sets with cross-grader market share (per-grader grades + share %, checklist size, % graded) | — | #### Graders `psa` (PSA) · `bgs` (Beckett / BGS) · `sgc` (SGC) · `cgc` (CGC) #### Categories `basketball-cards`, `baseball-cards`, `boxing-wrestling-cards-mma`, `football-cards`, `golf-cards`, `hockey-cards`, `soccer-cards`, `tcg-cards` (Pokémon / Yu-Gi-Oh! / MTG), `non-sport-cards`, `multi-sport-cards`, `misc-cards`, `packs`, `tickets`. ### Example recipes **Top 100 PSA-graded Pokémon cards of all time:** ```json { "operation": "top-cards", "grader": "psa", "category": "tcg-cards", "count": "100" } ```` **Every 2024 PSA basketball set, with gem rates:** ```json { "operation": "set-details", "grader": "psa", "category": "basketball-cards", "year": "2024" } ``` **All of one player's graded cards:** ```json { "operation": "player", "grader": "psa", "category": "basketball-cards", "playerName": "Michael Jordan" } ``` **A single card's population over time** (for cards with parallels, set `parallel` to match — look it up with *Cards in a set* first): ```json { "operation": "trend", "grader": "psa", "category": "tcg-cards", "year": "1999", "setName": "Pokemon Game", "playerName": "Charizard-Holo", "parallel": "Base" } ``` **Every card in a set, with individual gem rates** (match `setName` to how it reads on GemRate): ```json { "operation": "items", "grader": "psa", "category": "baseball-cards", "year": "2024", "setName": "Topps Chrome" } ``` **That whole set's graded population over time:** ```json { "operation": "set-trend", "grader": "psa", "category": "baseball-cards", "year": "2024", "setName": "Topps Chrome" } ``` **The same set's grading data as it stood on a past date** (historical replay; `date` is `YYYY-MM-DD`): ```json { "operation": "replay", "grader": "psa", "category": "baseball-cards", "year": "2024", "setName": "Topps Chrome", "date": "2025-01-01" } ``` **Full grade breakdown for one specific card** — a two-step flow. First search to get the card's `gemrate_id`: ```json { "operation": "search", "query": "Michael Jordan" } ``` Then pass that ID into `card-details` (copy the `gemrate_id` from any search result row): ```json { "operation": "card-details", "gemrateId": "PASTE_gemrate_id_FROM_SEARCH" } ``` **The full cross-grader Iconic Tracker (no parameters needed):** ```json { "operation": "iconic-tracker" } ``` **The Universal Pop Report — set-level cross-grader market share (also no parameters):** ```json { "operation": "universal-pop-report" } ``` **Search for sets by name** (same as card search, but returns sets): ```json { "operation": "search-sets", "query": "Topps Chrome 2024" } ``` **Dashboard datasets** — leave `dashboardDataset` blank for the main grading-trend table, or pick one (`category_df`, `player_data`, `set_data`, `card_data`). Either way the full payload is also saved to the run's key-value store under `DASHBOARD`: ```json { "operation": "dashboard", "dashboardDataset": "set_data" } ``` ### Input reference Set `operation`, then the parameters that operation needs. Everything else is optional. | Field | Type | Used by | Description | | -------------------- | ------- | ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | | `operation` | string | **required** | Which dataset to pull (see the operations table above). | | `query` | string | search, search-sets | Card or set name, e.g. `Michael Jordan`, `Charizard`, `Topps Chrome 2024`. Returns up to 10 matches. | | `gemrateId` | string | card-details | A card's `gemrate_id` from search results. | | `grader` | string | set/player/trend/replay/top-cards | `psa`, `bgs`, `sgc`, or `cgc`. Default `psa`. | | `category` | string | set-details, items, top-cards, player, trend, replay | Card category (see list above). | | `year` | string | set-details, items, trend, set-trend, replay | Set year, e.g. `2024`. | | `setName` | string | items, trend, set-trend, replay | Set name exactly as GemRate shows it, e.g. `Topps Chrome`. | | `playerName` | string | player, trend | Player/subject (player op) or the card's name (trend op). | | `parallel` | string | trend | Parallel for the trend card, e.g. `Base`, `Holo`. Must match for cards that have parallels. | | `cardNumber` | string | trend | Card number, to disambiguate same-named cards. | | `count` | string | top-cards | `100`, `500`, or `1000`. Default `100`. | | `date` | string | replay | `YYYY-MM-DD` — the date to replay a set's data as of. | | `dashboardDataset` | string | dashboard | Homepage table to return; blank = `grading_data`. Full payload (all tables) also saved to the key-value store. | | `search` | string | list operations | Post-filter: keep only rows whose text contains this string (case-insensitive). | | `limit` | integer | list operations | Cap the number of rows returned. `0` = no limit. | | `proxyConfiguration` | object | all | Proxy settings. Residential Apify Proxy is the default and recommended (clears Cloudflare). | ### Output Every result is one dataset row, tagged with the `operation` that produced it and a `scrapedAt` timestamp. Because each operation returns a different shape, the **Output tab has a ready-made table view per operation** — open the view selector and pick the one named after what you ran (**Cards**, **Sets**, **Card grading details**, **Trends over time**, **Iconic Tracker**, or **Universal Pop Report**). Every field is always in the JSON/CSV download regardless of the view. The exact fields depend on the operation. A **Search cards** row looks like this: ```json { "operation": "search", "name": "Michael Jordan", "description": "1990 Fleer Michael Jordan Base 26", "set_name": "Fleer", "year": "1990", "parallel": "Base", "card_number": "26", "category": "basketball-cards", "matched_grader": "psa", "gems": 10612, "gem_rate": 12.08, "total_population": 87870, "population_type": "Universal", "gemrate_id": "f84b6798d8ee0d1088039299380ced3d439dddd2", "scrapedAt": "2026-05-31T13:46:44.288Z" } ``` An **Iconic Tracker** row is far richer — it carries the per-grader grade-by-grade breakdown for all four graders plus percentile and trend fields (abbreviated here): ```json { "operation": "iconic-tracker", "rank": 1, "name": "Mickey Mantle", "set_name": "1952 Topps", "year": "1952", "psa_card_total_grades": 2156, "psa_card_gems": 6, "psa_card_gem_rate": "0.0028", "total_grades": 3490, "total_gem_rate": 0.0031, "cardladder": "https://www.cardladder.com/...", "scrapedAt": "2026-05-31T13:55:00.000Z" } ``` You can download the dataset in **JSON, CSV, Excel, or HTML**, or pull it via the API. For the **Dashboard datasets** operation with no specific dataset chosen, the full payload is also saved to the run's key-value store under the `DASHBOARD` key. #### Data fields Common fields across operations (each operation also includes its own extra columns — download JSON/CSV for the complete record): | Field | Description | | --------------------------------------------------------- | ---------------------------------------------------------------- | | `operation` | Which operation produced the row. | | `name`, `description` | Card / player / set name and full description. | | `gemrate_id` | GemRate's ID for a card (feed it into **Card grading details**). | | `grader`, `matched_grader` | Grading company for the row. | | `category`, `year`, `set_name`, `parallel`, `card_number` | Identifiers for the card / set. | | `total`, `gems`, `gem_rate` | Set-level total graded, gem count, and gem rate. | | `card_total_grades`, `card_gems`, `card_gem_rate` | Card-level total graded, gem count, and gem rate. | | `total_population`, `population_type` | Combined cross-grader population (search / card-details). | | `rank` | Rank within the Iconic Tracker. | | `date` | Date for trend / replay rows. | | `scrapedAt` | When the row was captured. | > **About gem rate:** GemRate reports it differently per endpoint — set and card breakdowns use a **0–1 fraction** (e.g. `0.92` = 92%), while search rows use a **0–100 percentage**. Read it accordingly when you analyze the output. ### Filtering & limiting The list-style operations accept optional post-processing so you can trim a large dataset: - **`search`** — keep only rows whose text contains a string (case-insensitive). - **`limit`** — cap the number of rows returned. For anything more (sorting, numeric thresholds), download the dataset and sort/filter it in your spreadsheet, database, or via the API — gem-rate scaling varies by endpoint, so doing it downstream is more reliable. ### How much does it cost to scrape GemRate? The two **search** operations use a lightweight API call — fast and very cheap. The other operations run a real browser (to clear GemRate's Cloudflare protection from Apify's network), so they use more compute — typically a few seconds and a fraction of a compute unit per run, at 2–4 GB. Runs are still short; cost scales with how many runs you do. On the Apify **free tier**, the monthly credits cover regular use. ### Tips & advanced options - **Two-step card lookup:** *Search cards by name* → copy a `gemrate_id` → *Card grading details* for the full per-grader breakdown. - **Population trends need exact inputs:** for *Card population trend*, `setName`, `parallel`, and `cardNumber` must match GemRate exactly, or the trend comes back empty — look them up with *Cards in a set* first. - **Incremental monitoring:** schedule *Set population trend* on your watchlist and route new rows into a sheet or Slack alert. - **Whole-market exports:** *Iconic Tracker* and *Universal Pop Report* take no parameters and return the broadest cross-grader datasets on the site in one run. - **Proxy:** keep the default **residential** Apify Proxy — the browser-based operations need it to clear Cloudflare. Datacenter proxies and no-proxy will be blocked for those operations. ### FAQ, disclaimers & support **Do I need a GemRate account or login?** No. GemRate's data is publicly accessible — just pick an operation and run. **Why does a set return no rows?** Set names must match GemRate exactly. Match `setName`, `year`, and `category` to how they appear on the site (use *Search sets by name* or *Cards in a set* to confirm the spelling). **What's the difference between *gems* and *gem rate*?** `gems` is the count of cards graded gem-mint (PSA 10 / BGS 9.5 etc.); `gem rate` is that count as a share of all graded copies. See the gem-rate note above for the scale per endpoint. **Is this affiliated with GemRate?** No. This is an independent, read-only Actor built on top of GemRate's public site. The endpoints are unofficial and may change without notice. Use the extracted data in line with GemRate's Terms of Service and applicable law. **Something looks off / I want a new field or operation.** Open an issue on the Actor's **Issues** tab with the input you used. Custom fields or a tailored version can be added on request. # Actor input Schema ## `operation` (type: `string`): What to fetch. Each operation uses only a few of the parameters below (see the field guide under "Parameters"). The Output tab has a matching table view per operation — pick the view named after your operation. ## `query` (type: `string`): Used by **Search cards** and **Search sets**. e.g. "Michael Jordan", "Charizard", or "Topps Chrome 2024". Returns up to 10 matches. ## `gemrateId` (type: `string`): Used by **Card grading details**. The card ID returned in search results (the gemrate\_id field). ## `grader` (type: `string`): Grading company. Used by all set/player/trend/replay/top-card operations. ## `category` (type: `string`): Card category. Used by set-details, items, top-cards, player, trend, set-trend, and replay. ## `year` (type: `string`): Set year, e.g. "2024". Used by set-details, items, trend, set-trend, and replay. ## `setName` (type: `string`): Set name, e.g. "Topps Chrome" or "Prismatic Evolutions". Used by items, trend, set-trend, and replay. Match the name as it appears on GemRate. ## `playerName` (type: `string`): Used by **Player cards** (the player/subject to list) and by **Card population trend** (the card's name, e.g. "Charizard"). ## `parallel` (type: `string`): Parallel for **Card population trend**, e.g. "Base", "Holo", "Silver Prizm". For cards that have parallels this must match the card's parallel exactly, or the trend returns no rows. Look it up with the *Cards in a set* operation first. ## `cardNumber` (type: `string`): Optional card number for **Card population trend** to disambiguate cards with the same name. ## `count` (type: `string`): How many cards **Top graded cards** returns: 100, 500, or 1000. ## `date` (type: `string`): Used by **Historical replay** — view a set's grading data as it stood on this date. ## `dashboardDataset` (type: `string`): Used by **Dashboard datasets**. Leave blank for the main grading-trend table (grading\_data), or pick another. Either way, the full payload (all tables) is also saved to the key-value store under DASHBOARD. ## `search` (type: `string`): Post-filter: keep only rows whose text fields contain this string (case-insensitive). Applies to the list-style operations. ## `limit` (type: `integer`): Cap the number of rows returned after filtering and sorting. 0 = no limit. ## `proxyConfiguration` (type: `object`): GemRate is behind Cloudflare. Most operations run in a real browser that needs a residential IP to clear Cloudflare from Apify's network — residential is the default and strongly recommended. The two search operations use a lightweight API and work on any proxy. ## Actor input object example ```json { "operation": "search", "query": "Michael Jordan", "grader": "psa", "count": "100", "limit": 0, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `results` (type: `string`): No description ## `dashboard` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "query": "Michael Jordan", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("amrameng/gemrate-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "query": "Michael Jordan", "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("amrameng/gemrate-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": "Michael Jordan", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call amrameng/gemrate-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=amrameng/gemrate-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "GemRate Card Grading Population & Sales Data Scraper", "description": "Card-grading population data from GemRate — PSA, Beckett, SGC, CGC — plus eBay sales trends. Search cards and sets, pull set/player breakdowns, top cards, population trends, historical replays, and dashboard data. Pick an operation, get structured JSON. Read-only.", "version": "0.1", "x-build-id": "2k6uw4AUUyL7FbEPz" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/amrameng~gemrate-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-amrameng-gemrate-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/amrameng~gemrate-scraper/runs": { "post": { "operationId": "runs-sync-amrameng-gemrate-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/amrameng~gemrate-scraper/run-sync": { "post": { "operationId": "run-sync-amrameng-gemrate-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "operation" ], "properties": { "operation": { "title": "Operation", "enum": [ "search", "search-sets", "card-details", "set-details", "items", "top-cards", "player", "trend", "set-trend", "replay", "dashboard", "iconic-tracker", "universal-pop-report" ], "type": "string", "description": "What to fetch. Each operation uses only a few of the parameters below (see the field guide under \"Parameters\"). The Output tab has a matching table view per operation — pick the view named after your operation.", "default": "search" }, "query": { "title": "Search query", "type": "string", "description": "Used by **Search cards** and **Search sets**. e.g. \"Michael Jordan\", \"Charizard\", or \"Topps Chrome 2024\". Returns up to 10 matches." }, "gemrateId": { "title": "GemRate ID", "type": "string", "description": "Used by **Card grading details**. The card ID returned in search results (the gemrate_id field)." }, "grader": { "title": "Grader", "enum": [ "psa", "bgs", "sgc", "cgc" ], "type": "string", "description": "Grading company. Used by all set/player/trend/replay/top-card operations.", "default": "psa" }, "category": { "title": "Category", "enum": [ "basketball-cards", "baseball-cards", "boxing-wrestling-cards-mma", "football-cards", "golf-cards", "hockey-cards", "soccer-cards", "tcg-cards", "non-sport-cards", "multi-sport-cards", "misc-cards", "packs", "tickets" ], "type": "string", "description": "Card category. Used by set-details, items, top-cards, player, trend, set-trend, and replay." }, "year": { "title": "Year", "type": "string", "description": "Set year, e.g. \"2024\". Used by set-details, items, trend, set-trend, and replay." }, "setName": { "title": "Set name", "type": "string", "description": "Set name, e.g. \"Topps Chrome\" or \"Prismatic Evolutions\". Used by items, trend, set-trend, and replay. Match the name as it appears on GemRate." }, "playerName": { "title": "Player / subject name", "type": "string", "description": "Used by **Player cards** (the player/subject to list) and by **Card population trend** (the card's name, e.g. \"Charizard\")." }, "parallel": { "title": "Parallel (trend)", "type": "string", "description": "Parallel for **Card population trend**, e.g. \"Base\", \"Holo\", \"Silver Prizm\". For cards that have parallels this must match the card's parallel exactly, or the trend returns no rows. Look it up with the *Cards in a set* operation first." }, "cardNumber": { "title": "Card number (trend, optional)", "type": "string", "description": "Optional card number for **Card population trend** to disambiguate cards with the same name." }, "count": { "title": "Top cards count", "enum": [ "100", "500", "1000" ], "type": "string", "description": "How many cards **Top graded cards** returns: 100, 500, or 1000.", "default": "100" }, "date": { "title": "Replay date (YYYY-MM-DD)", "pattern": "^\\d{4}-\\d{2}-\\d{2}$", "type": "string", "description": "Used by **Historical replay** — view a set's grading data as it stood on this date." }, "dashboardDataset": { "title": "Dashboard dataset", "enum": [ "grading_data", "category_df", "player_data", "set_data", "card_data" ], "type": "string", "description": "Used by **Dashboard datasets**. Leave blank for the main grading-trend table (grading_data), or pick another. Either way, the full payload (all tables) is also saved to the key-value store under DASHBOARD." }, "search": { "title": "Filter: contains text", "type": "string", "description": "Post-filter: keep only rows whose text fields contain this string (case-insensitive). Applies to the list-style operations." }, "limit": { "title": "Limit results", "minimum": 0, "type": "integer", "description": "Cap the number of rows returned after filtering and sorting. 0 = no limit.", "default": 0 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "GemRate is behind Cloudflare. Most operations run in a real browser that needs a residential IP to clear Cloudflare from Apify's network — residential is the default and strongly recommended. The two search operations use a lightweight API and work on any proxy.", "default": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } } }, "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 } } } } } } } } } } ```