satorntcg-mcp-server
OfficialIt exposes live SatornTCG inventory, pricing, P&L, eBay, and TCGplayer order workflows as MCP tools for an LLM client.
View active price alerts, gainers/losers, stale listings, and eBay listing price drift.
Summarize current inventory and look up latest TCGplayer market prices and cost basis by card name.
Calculate profit and loss per box or across the whole business.
List active or sold eBay listings.
Look up TCGplayer orders and line items by status or order number.
Create TCGplayer orders, match line items to cards, and sync placeholder listings with duplicate-sale guards.
Find TCGplayer orders whose listing/inventory sync never completed.
Generate TCGplayer packing-slip PDFs.
Run a network-connectivity diagnostic for outbound HTTPS and Supabase.
Tool calls are schema-validated and OpenTelemetry-traced.
Provides tools for retrieving active and sold eBay listings, enabling users to query eBay sales and listing data related to their TCG inventory.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@satorntcg-mcp-server What's underpriced in my inventory right now?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
satorntcg-mcp-server
An MCP server that exposes live TCG resale/inventory data — pricing, alerts, profit & loss, eBay listings — as tools an LLM client (Claude Desktop, Claude Code, etc.) can call directly. Instead of opening a dashboard, you can just ask: "what's underpriced right now" or "how is the Gothic box performing" and get an answer grounded in real data.
Built on top of SatornTCG, a Sorcery: Contested Realm resale/content operation backed by Supabase/Postgres.
Why this exists
This started as a resume project to learn MCP server design and observability, and turned into a tool I actually use day to day to query my own inventory and pricing data conversationally instead of clicking through a UI.
Related MCP server: Midpoint MCP server
Highlights
11 MCP tools over live business data (inventory, pricing, P&L, eBay listings, TCGplayer order sync, eBay deal scanning), each with a JSON input schema and server-side validation.
Guardrailed agent runner on the Claude API: read-only tool allowlist, argument checks against each tool's schema before every call, and a cap on tool rounds.
OpenTelemetry end to end: every tool call is a span with a child span per database query, slow calls are flagged, and trace context flows from agent to server through MCP request metadata. Traces go to Jaeger, and agent metrics go to Prometheus and Grafana.
Tests and evals: Node test runner suite (unit, MCP integration, tracing, retry), plus a live Claude tool-selection eval that also checks direct-answer, clarification, and refusal cases.
Author: Christopher Rogers. Portfolio: crogers.dev
What it exposes
Tool | Description |
| Active price alerts, gainers/losers, stale listings, listing-price drift |
| Current inventory: quantities owned/listed, latest prices |
| TCGplayer market price + cost basis lookup by card name |
| Profit & loss per box (purchase price vs. realized/unrealized pull value) |
| Overall business P&L across all boxes and listings |
| Active or sold eBay listings |
| Live eBay scan for Sorcery singles listed below TCGplayer market after resale costs (needs |
| TCGplayer orders synced from sale-notification emails, filterable by status or order number |
| Records a TCGplayer order and its line items (write tool) |
| Reconciliation: orders with no matching listing in the app |
| Generates a TCGplayer packing-slip PDF for an order |
Most tools are thin wrappers around a Postgres view — see src/tools/.
Architecture
Claude Desktop / Claude Code (MCP client)
│ stdio
▼
src/index.js ── registers tools, routes tool calls
│
▼
src/tools/*.js ── one file per domain, each tool = { name, description, inputSchema, handler }
│
▼
src/supabaseClient.js ── service-role Supabase client
│
▼
Postgres (Supabase) ── views: v_active_alerts, v_inventory_dashboard,
v_latest_prices, v_box_pnl, v_global_pnl,
v_ebay_active, v_ebay_sold, v_stale_listings,
v_price_gainers_losers, v_listing_price_alertsEvery tool call is traced with OpenTelemetry, exported to Jaeger — see Observability below.
Schema this expects
This server doesn't ship a demo database — it's meant to be pointed at a Postgres/Supabase project with equivalent views. If you're adapting this for your own data, the views above are just SELECTs over your own tables; swap the query in each src/tools/*.js file to match your schema. Column names referenced directly (e.g. card_id, name, tcg_market_price, cost_basis, dismissed) are the main thing to line up.
Setup
git clone <this-repo>
cd satorntcg-mcp-server
npm install
cp .env.example .env
# fill in SUPABASE_URL and SUPABASE_SERVICE_KEY in .env
npm startThe server speaks MCP over stdio, so it's meant to be launched by an MCP client, not run standalone in a terminal for interactive use. To test with Claude Desktop, add it to your MCP config (claude_desktop_config.json):
{
"mcpServers": {
"satorntcg": {
"command": "node",
"args": ["/absolute/path/to/satorntcg-mcp-server/src/index.js"]
}
}
}Restart Claude Desktop, and the tools above become available in conversation.
Agent runner (CLI)
agent/run-agent.js asks Claude one question and lets it call this server's read-only tools (get_inventory_summary, get_latest_prices) over MCP until it has an answer. It spawns src/index.js itself, so no MCP client is needed.
# .env needs SUPABASE_URL, SUPABASE_SERVICE_KEY and ANTHROPIC_API_KEY
ANTHROPIC_MODEL=claude-opus-5-5 node agent/run-agent.js "Show me my 5 most profitable cards"(PowerShell: $env:ANTHROPIC_MODEL="claude-opus-5-5"; node agent/run-agent.js "...")
It prints Claude's answer, then a diagnostics block with the stop reason, token counts, and each tool call (arguments, status, row count, duration). Tool output rows are never printed in diagnostics. Safeguards:
Only the two allowlisted tools are offered. Any other tool name Claude requests is rejected without being forwarded.
Arguments are checked against the tool's
inputSchemafromtools/listbeforetools/call. Unknown keys are rejected too. The server still runs its own validation.After 5 rounds of tool calls it stops and exits non-zero.
This queries the real Supabase project (read-only views). The loop logic is in agent/agentCore.js and is covered offline by test/agent.test.js.
Observability
Every tool call is wrapped in an OpenTelemetry span (tool.<name>), with each Supabase query the tool makes nested underneath it as its own db.query child span. That split is the point: a slow tool call in Jaeger tells you at a glance whether the time went into the DB round-trip or into everything else the handler did (matching, mapping, duplicate-guard checks, etc.), instead of being one opaque block of latency.
Each tool.* span carries:
mcp.tool.name,mcp.tool.args— which tool, called with whatmcp.tool.row_count— best-effort row count from the result, when there's an obvious array to countmcp.tool.duration_ms— total handler wall timemcp.tool.slow—trueoncemcp.tool.duration_msexceedsSLOW_TOOL_THRESHOLD_MS(1000ms, insrc/index.js) — lets you filter straight to the calls worth looking at without eyeballing durationsspan status
OK/ERROR, with the exception recorded on error
Each db.query child span carries db.table and, on success, db.row_count.
Traces export over OTLP/HTTP to OTEL_EXPORTER_OTLP_ENDPOINT (defaults to http://localhost:4318/v1/traces, i.e. a local collector/Jaeger — see .env.example). Spans are flushed on shutdown (SIGTERM/SIGINT, or the client closing the server's stdin), so a normal Claude Desktop restart doesn't lose the last few tool calls; see src/tracing.js for the shutdown handling and the reasoning behind its timeout.
Shutdown timing. The MCP server and the agent CLI both wait at most 2s (SHUTDOWN_TIMEOUT_MS in src/tracing.js) for spans, and the agent's metrics, to flush. That bounds the wait. It is not a guaranteed deadline for the process to exit:
On
SIGTERM/SIGINTthe process callsprocess.exit()as soon as the wait ends. It exits within about 2s, and anything still being sent is dropped.On a natural exit (the CLI finishing, or the server's stdin closing), Node only exits once nothing is left running, including an export still in flight. So each trace export is capped at 1.5s, retries included (
TRACE_EXPORT_TIMEOUT_MS; the OTLP default is 10s).Jaeger hung, or answering 429/502/503/504: exit happens about 1.5s late.
Jaeger not running (connection refused): no delay.
Either way, that run's spans are lost.
OTEL_EXPORTER_OTLP_TRACES_TIMEOUTorOTEL_EXPORTER_OTLP_TIMEOUT(milliseconds) replaces the 1.5s default, e.g. for a slower remote backend. A value above 2000 lets a natural exit wait that long.The timeout covers every export, including the batches the server sends every 5s while running. A local Jaeger answers in milliseconds; a batch that takes longer than 1.5s is dropped.
Agent traces
agent/run-agent.js exports its own spans (service satorntcg-agent, same exporter setup from src/tracing.js), one trace per run:
agent.request request-level attributes (table below)
├─ mcp.setup server spawn + tools/list
├─ claude.messages.create agent.round=0, tokens, finish reason
├─ mcp.call_tool get_inventory_summary agent.round=1, arg key names, agent.tool.status
│ └─ tool.get_inventory_summary (satorntcg-mcp-server)
│ └─ db.query (satorntcg-mcp-server)
└─ claude.messages.create agent.round=1agent.request attributes:
Attribute | Value |
|
|
|
|
| Last Claude |
| Tool uses Claude requested that the agent handled (executed or rejected). Same count as the diagnostics block |
| Rounds of tool execution whose results went back to Claude. Same as |
| Totals across every Claude call that returned. These are |
agent.outcome uses only what a run actually shows:
error: MCP setup failed, the Anthropic API returned an error, something threw, or the run hitmax_tool_rounds. The span status isERRORas well.unknown: everything else, including every normalend_turn. The agent gets back only free text, and an answer, a clarifying question ("which metric?") and a "can't do that with these tools" reply all end the same way. Classifying them would mean guessing from the text or from whether tools were called, soanswered,clarificationandunsupportedare defined inOUTCOMESbut never emitted. Emitting them needs a structured signal from the model, such as a final-response tool or output schema, which would change the agent's behavior. A run interrupted by a signal also keepsunknown, with aninterrupted by …error status.When a run fails before the agent loop returns, the two tool counts are left unset rather than reconstructed. Token totals still cover the Claude calls that completed.
Every span has
agent.duration_msand anOK/ERRORstatus.agent.tool.statusisok,tool_error(the tool returnedisError) ormcp_error(the protocol call threw). Tool uses the agent rejected before calling MCP (not allowlisted, invalid arguments) appear astool_use_rejectedevents onagent.request.Claude spans carry
gen_ai.usage.input_tokens/output_tokens(plus cache read/creation tokens when present),gen_ai.request.model,gen_ai.response.modelandgen_ai.response.finish_reasons.Not recorded in span attributes: the API key, the question or system prompt, message content, tool argument values, or anything from a tool result. The server's own
tool.*span still recordsmcp.tool.argsas described above.Known gap: NodeSDK's default resource detectors attach
process.command_argsto every agent trace, and for this CLI that includes the question. They also attachprocess.owner,host.nameandprocess.pid. Metrics avoid this with their own resource (see Agent metrics). Traces still carry it.On Ctrl+C or
SIGTERM, open spans are ended with aninterrupted by SIGINT/SIGTERMerror status and flushed before exit.OTEL_SDK_DISABLED=trueturns agent tracing off.
How the trace crosses into the server. stdio has no headers, so the agent sends W3C traceparent/tracestate in the tools/call request's params._meta, MCP's general-purpose metadata field, and src/index.js extracts it as the parent of its tool.* span. These keys are a convention between this agent and this server, not something MCP itself defines. Limitations:
Only
tools/callcarries context.initializeandtools/listaren't traced on the server, somcp.setuphas no server children.Clients that don't send these keys (Claude Desktop, Claude Code) get the old behavior: each tool call starts its own trace under satorntcg-mcp-server.
Because both processes export separately, the server's spans can show up a moment after the agent's if you open the trace immediately.
Agent metrics
agent/run-agent.js also records OpenTelemetry metrics (agent/agentMetrics.js):
Metric | Type | Labels | Recorded |
| counter, |
| Once per request, whether it succeeds, fails or is interrupted |
| histogram, |
| Same moment. Covers MCP server spawn through shutdown. Buckets 250ms–120s |
| counter, |
| Per MCP |
| counter, |
| Per Claude response, from |
agent.outcomeis the same value as on theagent.requestspan (errororunknown; see above). An interrupted run is counted asunknown.Labels are limited to the model ID, the outcome, and an allowlisted tool name. Any other name is recorded as
other. The question, card names, argument values and request IDs are never used as labels.A usage error (no question, no
ANTHROPIC_MODEL) never starts a request, so it isn't counted.Flush on exit: in
sdk-metrics1.x, shutting down aPeriodicExportingMetricReaderdoes not export what was recorded since the last 60s interval. That's every metric from a CLI run.shutdownTracing()insrc/tracing.jstherefore callsforceFlush()on the reader before shutting it down. The trace flush runs at the same time, not after it, so a slow Collector can't hold up traces.test/agentMetrics.test.jschecks both in child processes. For how long exit can take when the Collector misbehaves, see the limitations under Local Prometheus.
Where metrics go. Off by default. OTEL_METRICS_EXPORTER (the standard OTel variable) selects the exporter:
unset /
none: noMeterProvideris registered, and the instruments are no-ops.otlp: OTLP/HTTP to the local Collector inobservability/(see below). The default URL ishttp://localhost:4319/v1/metrics; override it withOTEL_EXPORTER_OTLP_METRICS_ENDPOINT. The agent never derives this URL fromOTEL_EXPORTER_OTLP_ENDPOINT, which is Jaeger's full traces URL.console: at exit, writes one JSON line per series to stderr (stdout stays just the answer). Use it for debugging without the stack:$env:OTEL_METRICS_EXPORTER = "console" node agent/run-agent.js "What does cost basis mean?" 2> metrics.log Select-String "\[metrics\]" metrics.loganything else: prints a warning, and nothing is exported.
Jaeger is a tracing backend and has no metrics receiver, so these metrics never appear in Jaeger.
Metrics use their own MeterProvider (src/tracing.js), whose resource is just service.name plus the SDK's constant telemetry.sdk.* attributes. NodeSDK's auto-detected resource, which traces still use, includes process.command_args (the question), process.owner, host.name and process.pid. The Prometheus exporter would turn those into labels, and a per-run pid would make every run its own series.
Local Prometheus (OpenTelemetry Collector)
observability/docker-compose.yml runs three containers, with every port bound to 127.0.0.1:
Service | Image | Host port | Role |
|
|
| Receives agent metrics (metrics pipeline only) |
| Prometheus exposition of the Collector's running totals | ||
|
|
| Scrapes |
|
|
| UI over Prometheus (provisioned data source, no dashboards yet) |
Traces don't go through the Collector. The agent and MCP server keep exporting straight to the standalone Jaeger container on 4318 (below), which is why the Collector takes 4319. Jaeger isn't in the Compose file, because it would collide with that container's name and ports.
Short-lived processes and counters. Every CLI run is a new process, and its cumulative counters start at 0. If each run exported cumulative values, the Collector would just replace the last run's agent.requests = 1 with the next run's 1, and the total would never grow. So the agent exports delta temporality, and the Collector's delta_to_cumulative processor adds each run onto one running series per label set. That works because the metric resource is identical for every run. Limitations:
The totals live in Collector memory. Restarting the Collector, or
docker compose down, resets them to 0. Prometheus treats that as an ordinary counter reset, and its stored history survives in theprometheus-datavolume.Idle series expire. A series not updated for 168h (
max_stale/metric_expiration) is dropped and starts again from 0 on its next run.increase()/rate()are approximate here. Prometheus extrapolates across sparse samples, and doesn't count a series' first value as an increase. Over a short window,sum(increase(agent_requests_total[1h]))came out as 3.2 when the true number was 1. Use them for trends. For exact counts, read the counter itself:sum(agent_requests_total)is the total since the Collector started.Metrics from a run are lost if the Collector is down, hung or returning errors when the run exits. Nothing is buffered on disk, and the failure is silent unless
OTEL_LOG_LEVEL=erroris set. How much later the CLI exits:Collector down (connection refused): no noticeable delay, the export fails at once.
Collector hung, or answering 429/502/503/504: about 1.5s. The metric exporter's
timeoutMillis(OTLP_EXPORT_TIMEOUT_MSinagent/agentMetrics.js) covers the request and its retries. The default would be 10s.Traces still reach Jaeger in both cases, because they're flushed alongside metrics rather than after them.
The 2s shutdown wait isn't a process deadline (see Shutdown timing). Traces and metrics time out separately and at the same time, so even with both the Collector and Jaeger hung, the CLI exits about 1.5s late.
delta_to_cumulativeis an alpha Collector component.
Name and unit changes. The Collector's Prometheus exporter rewrites OTel names:
OTel metric (unit) | Prometheus series |
|
|
|
|
|
|
|
|
Dots become underscores, in metric names and in labels:
gen_ai_request_model,agent_outcome,mcp_tool_name,agent_tool_outcome.Monotonic counters get
_total.Units in braces (
{request},{token}) are dropped;msbecomes_milliseconds.service.namebecomes thejoblabel (satorntcg-agent, kept byhonor_labels: true), andotel_scope_nameis added.Prometheus 3 stores histogram
levalues as floats ("2500.0").
Start, verify, stop (PowerShell, from the repo root):
# Start the stack (Jaeger keeps running separately)
docker compose -f observability/docker-compose.yml up -d
docker compose -f observability/docker-compose.yml ps
# Run the agent with OTLP metrics
$env:OTEL_METRICS_EXPORTER = "otlp"
node agent/run-agent.js "What does cost basis mean?"
# Wait one scrape interval (15s), then query Prometheus
Start-Sleep 20
Invoke-RestMethod "http://localhost:9090/api/v1/query?query=agent_requests_total" | ConvertTo-Json -Depth 6
Invoke-RestMethod "http://localhost:9090/api/v1/query?query=agent_tokens_input_total" | ConvertTo-Json -Depth 6
# What the Collector is currently exposing, before Prometheus scrapes it
(Invoke-WebRequest http://localhost:8889/metrics -UseBasicParsing).Content -split "`n" | Select-String "^agent_"
# Stop (add -v to also delete Prometheus' stored history)
docker compose -f observability/docker-compose.yml down
Remove-Item Env:OTEL_METRICS_EXPORTERGrafana. Prometheus is provisioned as the default data source from observability/grafana/provisioning/datasources/prometheus.yml, at http://prometheus:9090 (the Compose service name, not localhost, because Grafana's backend makes the request from inside its container). Log in at http://localhost:3000 as admin with Grafana's default password, which it asks you to change on first login. To choose the password up front instead, set GRAFANA_ADMIN_PASSWORD (shell or .env) before the first up; it only applies when the grafana-data volume is created. To check the connection (prompts for the password):
$cred = Get-Credential admin
Invoke-RestMethod http://localhost:3000/api/datasources/uid/prometheus/health -Credential $cred # status: OKOr open http://localhost:9090 and try these queries:
agent_requests_totalsum by (agent_outcome) (agent_requests_total)agent_tokens_input_totalagent_tool_calls_totalhistogram_quantile(0.5, sum by (le) (agent_request_duration_milliseconds_bucket))
After a run, each counter should have grown by that run's values. The token counters grow by the Tokens: line in that run's diagnostics block.
Running Jaeger locally
Jaeger's all-in-one image accepts OTLP/HTTP on the default port this server already exports to, so no extra config is needed:
docker run -d --name jaeger \
-p 16686:16686 \
-p 4318:4318 \
jaegertracing/all-in-one:latestThen start the server as usual (npm start, launched by Claude Desktop or run directly) and make a few tool calls. Open the Jaeger UI at http://localhost:16686, pick satorntcg-mcp-server from the Service dropdown, and click Find Traces. For agent runs, pick satorntcg-agent instead and open an agent.request trace; the server's tool.* and db.query spans appear nested under the agent's mcp.call_tool spans.

Security note
SUPABASE_SERVICE_KEY is the elevated service-role key, not the public anon key. This is safe here because the server only ever runs as a local process launched by a trusted MCP client (never in a browser bundle) — the same reasoning as using a service role key inside a Supabase Edge Function. Never commit .env; only .env.example (placeholder values) is tracked.
Roadmap
suggest_listingtool — draft an eBay listing from inventory + pricing dataHTTP/SSE transport for remote access, alongside the local stdio transport
Export OTel traces to a hosted backend (Honeycomb/Grafana) for a demo, in addition to local Jaeger
License
MIT — see LICENSE.
Available Tools
11 toolscreate_tcgplayer_orderA
Create a TCGplayer order and its line items, matching each line item to a card by exact name (foil printings are matched literally, e.g. "Sinterfee (Foil)" — do not strip "(Foil)" from card_name_raw). Also creates a matching "active" listing in tcgplayer_listings (same shape the dashboard's manual "create listing" flow produces: quantity_listed bumped, no sold_price/fee/cost_basis/net_profit/quantity_owned changes yet) — even though the order email means TCGplayer already has a committed buyer, these are booked as placeholders on file and finalized later through the existing chat-based "mark sold" flow once the packing slip is printed and the order actually ships. Safe to re-run: if order_number already exists, its line items are never (re-)created, and its listing/inventory sync is only (re-)attempted if it never completed the first time (e.g. a prior call errored or timed out after the order was recorded but before the listing was synced) — so a retry after a failed call finishes the sync instead of silently no-oping. Also guards against duplicating a sale that was already recorded manually: if any of this order's cards has a manually-created tcgplayer_listings row (not one this tool made) within 3 days of the order date, listing creation is skipped (the order/items are still recorded) and the response says which existing listing to check. Two auto-created listings for the same card from different orders are never treated as duplicates — each has its own order_number, so they're genuinely separate sales.
Inputs: items (required), order_number (required), ship_by, ordered_at, +3 more.
debug_networkA
DIAGNOSTIC ONLY: tests outbound HTTPS connectivity from this server process to a generic endpoint and to the configured Supabase URL, returning full error detail for troubleshooting.
Inputs: no named parameters.
get_box_pnlA
Get profit & loss per box (purchase price vs. realized/unrealized value of pulled cards). Use for "was Box X worth it" or "how is Gothic performing overall" questions.
Inputs: limit, box_id.
get_ebay_listingsA
Get eBay listings, either currently active or sold, for questions like "what do I have listed right now" or "what has sold recently".
Inputs: status (required), limit.
get_global_pnlA
Get overall business P&L across all boxes/listings (total spend vs. total realized + unrealized value). Use for "how is the business doing overall" questions.
Inputs: no named parameters.
get_inventory_summaryA
Get the current inventory dashboard: cards on hand, quantities owned/listed, and latest market prices. Use for questions like "what do I have in stock" or "what am I sitting on that I should list".
Inputs: limit, name_contains.
get_latest_pricesA
Get latest TCGplayer market prices and cost basis for cards, optionally filtered by name. Use for "what is X worth" or "what did I pay vs. what is it worth now" questions.
Inputs: limit, name_contains.
get_orders_missing_listingsA
Find TCGplayer orders whose listing/inventory sync never completed — a direct comparison of tcgplayer_orders/tcgplayer_order_items against tcgplayer_listings, not an inference from quantity_listed or updated_at (those can shift for unrelated reasons, e.g. a price refresh, and give a false read). An order counts as synced if it has its own auto-created listing (tcgplayer_listings.notes = "Auto-created from TCGplayer order <order_number>"), or if listing creation was correctly skipped because a manual listing already covered one of its cards within 3 days of the order date — the same duplicate-sale guard create_tcgplayer_order itself uses. An auto-created listing belonging to a different order never counts as coverage, since that guard only ever fires against manual listings. Anything else is flagged as missing, listing every line item on the order since a failed sync never lists any of them. Run with since set to the start of an order-capture run to catch a bad sync within the hour; run with no since for a full backlog sweep.
Inputs: limit, since.
get_price_alertsA
Get current, non-dismissed price alerts, plus optional context on eBay listing price alerts and stale listings. Use this to answer questions like "what should I look at today" or "anything moving I should react to".
Inputs: limit, include_listing_alerts, include_stale_listings.
get_tcgplayer_ordersA
Get TCGplayer orders and their line items, optionally filtered by status (new/shipped) or order number. Use for questions like "what TCGplayer orders do I need to ship" or "what did order X contain".
Inputs: limit, status, order_number.
print_packing_slipA
Generate TCGplayer packing-slip PDF(s) for one or more order numbers by calling the Seller Portal's export API directly (bypasses the "Packing Slip" button, which stopped responding to automated clicks). Saves each PDF to a local packing-slips/ folder and returns its path — open or print that file yourself. If format is omitted, it's chosen automatically per order from tcgplayer_orders.order_total: orders below $20 print as "LeftWindowedEnvelope" (single #10 windowed envelope), orders at or above that print as "Default" (standard full-page). A mixed batch under auto mode is split into one export call per format, producing multiple PDFs. Pass format explicitly to force one format for every requested order instead. Requires TCGPLAYER_COOKIE in .env: a session cookie captured from a logged-in Seller Portal tab (DevTools → Network → any request → Copy as cURL → take the Cookie header value). That cookie expires/rotates periodically — a 401/403 here means it needs refreshing.
Inputs: order_numbers (required), format.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
Most tools map to a distinct resource/action (inventory, prices, alerts, PnL, orders, listings, packing slips), but get_inventory_summary and get_latest_prices both surface TCGplayer market prices, so an agent could pick either for price questions. get_orders_missing_listings also requires careful reading to separate it from create_tcgplayer_order's sync behavior.
Every tool uses snake_case with a clear verb first (get, create, print, debug) and a noun object, and read tools consistently start with get_. There are no mixed conventions or vague verbs.
11 tools is well within the ideal 3-15 range and the set is scoped to a specific TCG reseller operation: reads, order intake, reconciliation, and packing slips. No tool feels redundant or filler; even debug_network serves a clear ops purpose.
The set covers read-only dashboards, TCGplayer order creation, missing-sync reconciliation, and packing slips, but it lacks lifecycle operations such as marking orders shipped/sold, dismissing price alerts, or updating listings. create_tcgplayer_order explicitly defers finalization to an external chat-based 'mark sold' flow, which is a notable dead end for agents.
Maintenance
Related MCP Connectors
Live data for AI agents. Search the catalog, read the price, call the tool; keys stay server-side.
Live crypto + IDX stock market intelligence for AI agents — 19 tools, no API key.
Real SEC, 13F, insider, congress & macro data your AI agent can cite. Hosted MCP, 24 tools.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvides access to TCGplayer trading card data, including search, product details, pricing, and market information, enabling natural language queries for card analysis.1-
- FlicenseNot gradedqualityBmaintenanceEnables AI assistants to look up trading-card market values across Pokémon, Magic, sports and other TCG catalogs, including raw prices by condition, graded ladders, price history, trending movers and set checklists. It also calculates grading ROI — gem premiums, net profit after fees, expected value and break-even gem rates — so collectors can decide whether a card is worth submitting.-

@pokemontcgapi/mcpofficial
AlicenseAqualityBmaintenanceEnables agents to search and query Pokémon TCG cards and sets, retrieve priced card data with provenance, and identify cards from images through eight read-only tools.8368 npmMIT- AlicenseNot gradedqualityCmaintenanceEnables AI agents to price trading cards and sealed products across 14 games with sourced, dated quotes, graded medians, PSA populations, eBay sold data and 365 days of history. Also supports card identification from free text or photo, batch lookups, and side-by-side price comparisons through 16 read-only tools.1MIT