Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchSome links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Use TCGplayer’s approved REST API, not an HTML scraper. The current developer documentation describes API version v1.39.0, bearer-token authentication, catalog and search resources for finding products, and pricing resources for market and condition-level data. TCGplayer also says it is no longer granting new API access, so this workflow is intended for developers who already have an approved API Developer Key.
Automated collection from the website itself is restricted by the API Terms. A crawler, browser script, bot or scraper that gathers TCGplayer content outside the API can violate those terms. The sections below show how to authenticate, identify product and SKU IDs, retrieve prices, handle missing values, and operate an existing integration safely.
Check access and permitted use first
You need an existing approved key
Confirm that your account already has an API Developer Key. TCGplayer’s current Getting Started guide states: “We are no longer granting new API access at this time.” Do not build a production plan around obtaining a new key. If you have a key, keep its client credentials server-side and never ship them in browser JavaScript, a mobile app, a public repository or a screenshot.
Use the API for data collection
The API Terms & Conditions, updated June 8, 2022, limit access to purposes approved by TCGplayer. They prohibit automated collection through crawlers, scrapers, bots, robots, scripts, browser plugins or add-ons outside the API. They also restrict competing services, commercial or competitive redistribution of TCG Content, combining TCGplayer pricing with third-party pricing, and excessive or abusive request volume.
#1 Best Overall
- Used Book in Good Condition
Design your application around the specific purpose approved for your key. If that purpose changes, obtain written approval before expanding it.
The API workflow: discover, identify, price
- Authenticate. Exchange the approved client credentials through the documented token flow and receive a bearer token.
- Discover the catalog. List categories, search products and inspect product records.
- Record stable identifiers. Store the TCGplayer product ID and, where applicable, each SKU ID. Names are not reliable identifiers.
- Retrieve prices. Use product pricing for market/low/mid/high/buylist values or SKU pricing for condition-level values.
- Present attribution. Show the required TCGplayer notice and link each displayed item to a relevant TCGplayer product or search page.
- Operate conservatively. Cache permitted responses, limit concurrency, protect credentials and monitor failures.
Authenticate with a bearer token
The following examples use the endpoint names documented for the v1.39.0 API. Put credentials in environment variables or a secret manager. The token response includes an expiration value; cache the token only until that expiration and request a new one afterward.
cURL token request
curl -X POST "https://api.tcgplayer.com/token"
-H "Content-Type: application/x-www-form-urlencoded"
--data-urlencode "grant_type=client_credentials"
--data-urlencode "client_id=$TCGPLAYER_CLIENT_ID"
--data-urlencode "client_secret=$TCGPLAYER_CLIENT_SECRET"Read the access token from the JSON response without logging the response in a shared build log. A typical API request then supplies Authorization: Bearer YOUR_TOKEN.
Python: token, catalog and pricing calls
import os
import time
import requests
BASE = "https://api.tcgplayer.com"
CLIENT_ID = os.environ["TCGPLAYER_CLIENT_ID"]
CLIENT_SECRET = os.environ["TCGPLAYER_CLIENT_SECRET"]
def get_token():
response = requests.post(
f"{BASE}/token",
data={
"grant_type": "client_credentials",
"client_id": CLIENT_ID,
"client_secret": CLIENT_SECRET,
},
timeout=30,
)
response.raise_for_status()
payload = response.json()
# Keep the token in memory only until its documented expiry.
return payload["access_token"], int(payload.get("expires_in", 0))
token, expires_in = get_token()
headers = {"Authorization": f"Bearer {token}"}
# Discover categories.
categories = requests.get(
f"{BASE}/catalog/categories", headers=headers, timeout=30
)
categories.raise_for_status()
# Look up products in a category. Supply a real category ID and paging values.
category_id = 1
products = requests.get(
f"{BASE}/catalog/products/{category_id}",
headers=headers,
params={"limit": 50, "offset": 0},
timeout=30,
)
products.raise_for_status()
product_rows = products.json().get("results", [])
for product in product_rows:
product_id = product["productId"]
price_response = requests.get(
f"{BASE}/pricing/product/{product_id}",
headers=headers,
timeout=30,
)
price_response.raise_for_status()
print(product_id, price_response.json())Category IDs, paging limits and response field names should be checked against the documentation available to your account. Treat this as a server-side starting point, not code to paste into a public client.
Node.js: call a catalog endpoint
const token = process.env.TCGPLAYER_ACCESS_TOKEN;
if (!token) throw new Error('Set TCGPLAYER_ACCESS_TOKEN');
const url = new URL('https://api.tcgplayer.com/catalog/categories');
const res = await fetch(url, {
headers: { Authorization: `Bearer ${token}` }
});
if (!res.ok) {
throw new Error(`TCGplayer returned ${res.status}: ${await res.text()}`);
}
const data = await res.json();
console.log(JSON.stringify(data, null, 2));Choose the endpoint for the job
Catalog, product, advanced-search and pricing resources solve different problems. Keeping those stages separate prevents a common error: trying to infer a price from a product name before you have the correct product or SKU identifier.
| Need | Resource family | What to retain |
|---|---|---|
| Browse available lines | Catalog categories | Category ID and display name |
| Find matching products | Catalog products | Product ID, name and category context |
| Filter by several attributes | Advanced search | Search criteria plus returned product IDs |
| One product’s aggregate prices | Product pricing | Market, low, mid, high and buylist fields when present |
| Specific printing/condition | SKU pricing | SKU ID, condition and condition-level price fields |
Catalog discovery
Start with categories when you know the game or product family but not its internal ID. Product results provide the identifier needed by later detail and pricing calls. For repeat jobs, persist the ID-to-name mapping and refresh it deliberately instead of searching the entire catalog on every run.
Advanced search
Use advanced search when a name alone is ambiguous and you need attribute filters. Save the exact filter set with the returned IDs so another run can be audited. Do not assume that a human-readable title uniquely identifies a card, set, printing or language.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Retrieve and interpret prices
Product-level prices
A product pricing response can expose market, low, mid, high and buylist values. These are useful for a dashboard or valuation report when you want an aggregate view of a product rather than one condition or seller listing.
Rank #3
- Used Book in Good Condition
SKU-level and condition prices
Use the SKU endpoint when condition or a particular variant matters. A SKU may represent a specific printing or condition combination. Preserve the SKU ID alongside the returned condition so that later updates do not accidentally merge unlike items.
Null is not zero
If a condition price is null, interpret it as “no listing at that condition” rather than a zero-dollar price. Keep the null in storage, omit it from arithmetic, and show an explicit “not available” state in a user interface. Converting null to zero will understate averages and can trigger false alerts.
Python helper with explicit missing-value handling
def read_condition_prices(payload):
rows = []
for row in payload.get("results", []):
value = row.get("price")
rows.append({
"sku_id": row.get("skuId"),
"condition": row.get("condition"),
"price": float(value) if value is not None else None,
"has_listing": value is not None,
})
return rowsStore the retrieval timestamp and the raw response or a hash of it. Prices change, and a later analyst should be able to distinguish a changed market from a changed query.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Build a production-safe collector
Cache and schedule deliberately
Cache responses for the period appropriate to your approved use. A cache reduces duplicate calls and protects you from accidentally polling the same product in parallel. Invalidate entries when a user requests a fresh view or when your documented data policy requires it.
Control concurrency and retries
Use a bounded worker pool, exponential backoff for transient failures and a maximum retry count. Do not retry authentication failures indefinitely. Record HTTP status, endpoint, product or SKU ID, attempt number and correlation ID, but redact tokens and client secrets from every log.
Keep identifiers and provenance
A durable record should include product ID or SKU ID, query parameters, retrieval time, response status, the price fields returned and the source label. Never silently combine TCGplayer values with prices from another marketplace when the terms prohibit that use.
Protect credentials
- Keep client credentials in a server-side secret manager.
- Use separate credentials for development and production when your approval permits it.
- Rotate keys after a suspected leak and remove them from repository history.
- Restrict store-authorized tokens to the smallest service that needs them.
General catalog access is not store authorization
A general catalog integration identifies products and obtains catalog pricing through the API. A store access token represents a separate contract and can expose pricing and inventory, including modification capabilities. Treat that token as a high-impact secret: isolate it, audit every operation and do not assume that catalog approval authorizes inventory changes.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsAttribution is part of the interface
API-powered interfaces must identify TCGplayer as the pricing source and provide a relevant product or search link. Include this exact notice wherever your integration presents TCGplayer data:
This product uses TCGplayer data but is not endorsed or certified by TCGplayer.
Place the notice near the prices, not only in a buried legal page. A product detail view should link to that product on TCGplayer; a search or aggregate view should link to the corresponding search result when an individual product link is not appropriate.
Common failures and fixes
| Symptom | Likely cause | Fix |
|---|---|---|
| 401 Unauthorized | Expired token, missing Bearer prefix or wrong environment variable | Request a fresh token, send Authorization: Bearer TOKEN and verify the server-side secret. |
| 403 Forbidden | Credential lacks approval for the resource or purpose | Stop retrying; confirm the approved scope with TCGplayer. |
| Empty product results | Wrong category, filter or page offset | Test category discovery first, then simplify filters and inspect pagination. |
| Prices appear as zero | Application converted null to numeric zero | Preserve null and render “no listing at this condition.” |
| 429 or repeated throttling | Too much concurrency or polling | Reduce workers, add backoff and increase cache coverage. |
| Different products share one price | Name-based matching merged variants | Match on product ID and SKU ID, with condition and printing fields. |
| Inventory call can modify data | Store token used where catalog token was intended | Separate credentials and review the store contract before enabling writes. |
| Attribution review fails | Notice or product/search link missing | Add the verbatim notice next to the displayed TCGplayer-derived values. |
What to test before release
- Token expiration causes a controlled refresh rather than a crash or infinite loop.
- Pagination does not skip or duplicate products.
- Two variants with similar names remain separate by ID.
- Null condition prices stay null through storage, calculations and UI output.
- Retries stop on authorization errors and respect server throttling.
- Logs contain no client secret, bearer token or store token.
- Every screen showing TCGplayer pricing contains the required attribution and an appropriate link.
Or skip the browser setup
ScreenshotNeo is useful when you need a visual capture of a page for QA or documentation; it is not a replacement for TCGplayer’s approved data API, and it must not be used to automate collection prohibited by the API Terms. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups and chat widgets. Bot checks, blank pages, timeouts, failed loads and cache hits are not billed as clean shots, and each response reports the page verdict and billing status.
One GET request returns PNG, JPEG, WebP or PDF. The API also supports full-page and element captures, device presets, dark mode, retina scale, custom CSS and JavaScript, request blocking, cookies and headers, signed links, asynchronous jobs, bulk capture and an MCP server with take_screenshot, get_page_info and capture_pdf for Claude, Cursor and other MCP clients. See the ScreenshotNeo documentation for parameters.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://www.tcgplayer.com -o shot.webpThe Free plan includes 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 shots; yearly billing provides two months free. Create a free ScreenshotNeo account to try it without a card.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
