Reliquary
REMOTE · RELIQUARY.GG
Your Magic: The Gathering collection, decks and trades, with every shared copy disclosed.
Available components
Last scanned (15 hours ago)
Scores higher than 72% of remote servers
Reachable. Last reached 21 Nov 2026.
Category Entertainment and Games
How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. How we score → Why this is hard to score →
Endpoint Security100
- The endpoint's TLS certificate is valid, in date, and uses a strong key. View diagnostics → Pass
- Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token. View diagnostics → Pass
- HTTPS is enforced; there's no plaintext access path. View diagnostics → Pass
- The HSTS (Strict-Transport-Security) header is present. View diagnostics → Pass
- DNSSEC is configured correctly; the domain's records validate against the full chain to the root. View diagnostics → Pass
- The authorisation server supports Client ID Metadata Documents, the current MCP client-registration mechanism. View diagnostics → Pass
Transport & Reachability100
- Verified streamable-http transport via a live MCP handshake. View diagnostics → Pass
Schema Quality & AI Usability74
- 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).Pass
- AI-judged instruction clarity (good).Pass
- Context-footprint check failed: tool/resource definitions use about 17233 tokens (~226/item across 76 items; 74 tools + 2 resources), over budget; trim descriptions and params. See how to fix → Fail
- Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management7
- Stability observed for 2 of 30 days with no destabilising changes; credit accrues until the full window elapses.Partial
Tool Coverage88
- 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
- 59% of tool parameters carry a description.Partial
- Structured output schemas are declared (55% of tools); any adoption earns full credit.Pass
Tool Safety50
- Injection-marker check failed: the description of tool "read_share_link" contains an instruction to conceal the call from the user, the text "never tell the user", at byte 520 of that field. See how to fix → Fail
- All 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.Pass
- An AI judge read all 76 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities100
- Implements a current MCP spec version (2026-07-28).Pass
- Supports UI / widget rendering.Pass
Checks we ran (14)
- TLS certificate
- Authorization
- HTTPS
- HSTS header
- DNSSEC
- Transport
- Schema quality
- Stability
- Tool coverage
- Injection markers
- Destructive annotations
- Judged manipulation
- MCP protocol
- Capabilities
Does not apply to this hosted endpoint (2)
- Supply Chain SecurityScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
- Provenance & TransparencyScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
The score does not measure everything. What the score does not measure →
Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.
- 20 Nov 26 +1
- Stability: unverified → 0.03 ▲ functional
- 19 Nov 26 +37
- Injection markers: unverified → fail ▼ security
- Transport: unverified → pass ▲ security
- First check of Judged manipulation: pass security
- Authorization: Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token. security
- MCP protocol: unverified → pass ▲ functional
- Schema quality: unverified → 100 ▲ functional
- Tool coverage: unverified → 100 ▲ functional
- First check of Schema quality: fail functional
- First check of Schema quality: fail functional
- First check of Capabilities: pass functional
- First check of Tool coverage: 55 functional
- First check of Destructive annotations: 100 functional
- First check of Tool coverage: 59 functional
- First check of Schema quality: good functional
- 10 Nov 26 40
First indexed and scored.
Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.
Captured 21 Nov 2026 · Probed https://reliquary.gg/mcp
TLS valid
Negotiated TLS 1.3 with TLS_AES_128_GCM_SHA256 .
| Subject | Issuer | Valid from | Valid until | Key | Signature | Serial |
|---|---|---|---|---|---|---|
| CN=reliquary.gg | CN=WE1,O=Google Trust Services,C=US | 9 Oct 2026 | 7 Jan 2027 | ECDSA 256 | ECDSA-SHA256 | 86fe7de3067fa02713b87bfd96935ab0 |
| SANs: reliquary.gg, *.reliquary.gg | ||||||
| CN=WE1,O=Google Trust Services,C=US (CA) | CN=GTS Root R4,O=Google Trust Services LLC,C=US | 13 Dec 2023 | 20 Feb 2029 | ECDSA 256 | ECDSA-SHA384 | 7ff31977972c224a76155d13b6d685e3 |
| CN=GTS Root R4,O=Google Trust Services LLC,C=US (CA) | CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa,C=BE | 15 Nov 2023 | 28 Jan 2028 | ECDSA 384 | SHA256-RSA | 7fe530bf331343bedd821610493d8a1b |
Background: What to check on a remote MCP endpoint →
DNSSEC secure
Validation of reliquary.gg. — Secure
| Zone | DS | Keys | Algorithms | Outcome |
|---|---|---|---|---|
| . | Trust anchor | 20326, 38696 | 8, 8 | Verified |
| gg. | DS published | 4975 | 8 | Verified |
| reliquary.gg. | DS published | 2371 | 13 | Verified |
| reliquary.gg. | Verified address RRset verified with the apex keys |
Authentication Enforced and verified
The endpoint asked for a token and published valid RFC 9728 metadata describing how to get one.
| Result | Enforced and verified |
|---|---|
| Enforced | On tool calls |
| HTTP status | 200 |
WWW-Authenticate challenge Bearer realm="OAuth", error="invalid_token", error_description="This needs the player's Reliquary account: sign in to Reliquary to continue.", resource_metadata="https://reliquary.gg/.well-known/oauth-protected-resource/mcp", scope="reliquary"
Bearer realm="OAuth", error="invalid_token", error_description="This needs the player's Reliquary account: sign in to Reliquary to continue.", resource_metadata="https://reliquary.gg/.well-known/oauth-protected-resource/mcp", scope="reliquary" | Header | Value |
|---|---|
| strict-transport-security | max-age=15552000 |
| x-content-type-options | nosniff |
Protected resource metadata
| Document | https://reliquary.gg/.well-known/oauth-protected-resource/mcp |
|---|---|
| Retrieved | Yes |
| Resource | https://reliquary.gg/mcp |
| Authorisation server | https://reliquary.gg |
Background: How OAuth 2.1 works in the 2026 MCP spec →
Transports 2 probes
| Transport | URL | Outcome | Status | Location |
|---|---|---|---|---|
| streamable-http | https://reliquary.gg/mcp | Verified | 200 | |
| http (plaintext) | http://reliquary.gg/mcp | HTTPS enforced | 301 | https://reliquary.gg/mcp |
The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →
accept_friend Accept friend ~75
Accept a circle request another player sent the current user (my_circle lists them under requests_received). Both become friends at once: each sees what the other's handle publishes, in match_circle. Counts against the friends the account's plan holds.
| Name | Type | Req | Description |
|---|---|---|---|
| handle | string | yes | The handle of the player who sent the request, with its @ |
No output schema declared.
No examples provided.
add_friend Add friend ~203
Ask another player into the current user's trade circle by their handle ("@name"). Friends are matched against each other in one call (match_circle). A request reaches only a handle that has a wantlist or tradelist published; any other handle answers "Nothing is published under @name", the same as a lookup, so this never tells whether a player exists. The user needs a handle of their own (set_handle): it is the only thing the friend sees of them. status "pending" waits for the friend to accept; a request they already sent is accepted at once ("accepted"). What a friend can see: exactly what the handle publishes (wantlists and tradelists), never the collection, a deck share, a name or an email. The account's plan holds a number of friends, requests sent included: past it the answer is a plan limit naming the page that describes plans.
| Name | Type | Req | Description |
|---|---|---|---|
| handle | string | yes | The friend's handle, written with its @ |
No output schema declared.
No examples provided.
add_holdings Add holdings ~312
Add physical cards to the collection (bulk). Each item is a card reference (scryfall_id, or name [+ set_code, collector_number]) plus holding attributes. quantity ≥ 1 identical copies form one stack. Defaults: finish nonfoil, condition NM, lang en, origin "single", location "Unsorted" (created if missing; any unknown location name is auto-created). purchase_price is PER CARD in purchase_currency (USD/EUR/CHF). Unresolvable names are returned under "unresolved", the rest are added. A set_code (and collector_number) names one printing: an item whose card is not there comes back under "unresolved", naming the nearest printing. The list is added in one write: an item the collection refuses (an origin printed_proxy or bought_proxy with is_proxy false, a blank location) refuses the whole call and nothing is added. A name that is no card's exact name was added as Scryfall's closest match, and a name in another language as its English card: each is listed under "inexact" with the card it became (matched_by fuzzy or other_language). Tell the user which card was added for each fuzzy one. From a photo of cards, every name, set and finish is your own reading: list them and get the user's yes before adding.
| Name | Type | Req | Description |
|---|---|---|---|
| items | array | yes | Max 75 items per call (Scryfall batch limit). Send the whole list in one call: it is resolved in one batch. |
No output schema declared.
No examples provided.
add_wants Add wants ~249
Add cards to a deck's list (its wantlist), or to the personal deck-independent wantlist when deck is omitted. Send the whole list in ONE call (max 75 items): it is resolved and written in one batch. section: main (default) or sideboard, per item or for the whole call; commander formats have no sideboard. By default a want accepts ANY printing of the card (oracle-level). Set pin:true with a specific printing to require exactly that printing. Duplicate adds merge quantities. Adding a card claims nothing: each added row comes back with its coverage from the collection — allocated, shared_in, claimable (free copies you own, not yet claimed), missing — and proxies_allocated. Relay shared_detail / also_shared_with and proxies as deck_status requires. Next step: claim_from_collection. lang per item: the language the row asks for (Scryfall's code: de, ja, zhs…), a preference that trading matches first.
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | – | Deck id or name; omit for the personal wantlist |
| items | array | yes | – |
| section | string | – | Section for every item without its own (default main) |
No output schema declared.
No examples provided.
allocate Allocate ~159
Allocate copies of a holding (holding_id from search_collection/where_is) to a deck (id or name). shared:false (default) claims free copies exclusively — the sum of non-shared allocations can never exceed the stack size. shared:true deliberately shares copies that other decks also use (always disclose: which decks, where the card physically is). status "staged" (default) earmarks without moving; "sleeved" also physically moves the cards into the deck's location (splitting the stack when only part of it is sleeved).
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | yes | Deck id or name |
| holding_id | string | yes | – |
| quantity | integer | yes | – |
| shared | boolean | – | – |
| status | string | – | – |
No output schema declared.
No examples provided.
allocation_conflicts Allocation conflicts ~56
Decks that cannot be physically assembled at the same time: holdings promised (shared + non-shared) to more decks than copies exist. Use after claim_from_collection with allow_shared, and before the user takes decks to an event.
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| conflicts | array | yes | – |
| summary | string | yes | – |
No examples provided.
answer_swap Answer swap ~193
Answer a swap: approve or decline one proposed to the current user, or withdraw one they proposed. Approve moves cards in both collections at once: each copy given leaves its owner (the claims it no longer fits released, and named), each copy received lands in Unsorted as a trade. Without confirm: true, approve is a dry run: show the user what they give, receive and what would_release names, and ask before confirming. `add_to` ticks, for a card the user receives, the deck of theirs that claims it: only on the user's say-so. Refused, with nothing moved, when a copy is gone or changed since the proposal. Decline and withdraw move nothing.
| Name | Type | Req | Description |
|---|---|---|---|
| add_to | array | – | – |
| answer | string | yes | – |
| confirm | boolean | – | approve only: true to move the cards; without it nothing moves |
| swap_id | string | yes | – |
No output schema declared.
No examples provided.
audit_location Audit location ~65
Reconciliation view for a location (id or name): every holding physically there, plus — for deck locations — sleeved allocations that claim to be there, and any mismatches (allocation says sleeved but the stack is elsewhere).
| Name | Type | Req | Description |
|---|---|---|---|
| location | string | yes | Location id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| location | object | yes | – |
| mismatches | array | yes | Claims sleeved here whose stack is physically elsewhere |
| physically_here | array | yes | – |
| sleeved_here_on_paper | array | yes | A deck place: the claims sleeved into this deck |
| total_cards | number | yes | – |
No examples provided.
cancel_invite Cancel invite ~98
Take back an invite link the current user made (my_circle lists them, with their code): an open link stops bringing anyone in, and a link a newcomer used has its circle request withdrawn. Either way its place in the plan's circle is free again. A link whose player accepted is a friend now: remove_friend instead.
| Name | Type | Req | Description |
|---|---|---|---|
| code | string | yes | The link's code, the part after /i/ (or the whole link) |
No output schema declared.
No examples provided.
card_detail Card detail ~598
Everything about one card: oracle data (mana cost, type line, rules text, color identity, legalities — the map includes paupercommander (Pauper EDH: whether the card may sit in the 99) and duel (Duel Commander); card.pdh_commander separately flags cards that can LEAD a Pauper EDH deck, i.e. printed at uncommon with a creature/Vehicle/Spacecraft front face — legendary is NOT required in PDH), the focused printing (set, collector number, rarity, finishes, USD/EUR prices), EVERY printing across all sets with the user's per-printing ownership (qty_real / qty_real_foil / qty_proxy; set_digital=1 marks MTGO/Arena-only printings), and the user's holdings of any printing with physical location and deck allocations. Answers "do I own this card, and in which printings?" — use it before suggesting a purchase. card.rulings: the card's official rulings (published_at, source "wotc" = Wizards of the Coast or "scryfall", comment), from Scryfall's rulings file as of the catalogue's last load; quote them when asked how the card works, or how it works with another card. Reference by scryfall_id, by name (+ optional set_code/collector_number), or by oracle_id (the newest printing becomes the focus). A first lookup may read the card's printings and prices live from Scryfall (card data kept in the shared catalogue for 7 days; nothing in the user's account changes). DISCLOSURE: qty_proxy copies are proxies — physically present but never counted as owned; holdings with shared=true allocations must be relayed as "also allocated to …". Before the user signs in, it answers from the catalogue alone with signed_in: false: no qty_* fields, holdings or totals, so say nothing about what they own, and a card newer than the catalogue is not found until they sign in.
| Name | Type | Req | Description |
|---|---|---|---|
| collector_number | string | – | Collector number within the set |
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| name | string | – | Card name in English or any language Scryfall prints ("Blitzschlag", "Foudre", "稲妻"), used when scryfall_id is absent; an English name is also fuzzy-resolved via Scryfall |
| oracle_id | string | – | Oracle id shared by all printings — use when no specific printing is meant |
| scryfall_id | string | – | Exact Scryfall printing id, if known |
| set_code | string | – | Set code, e.g. "2xm" |
| Name | Type | Req | Description |
|---|---|---|---|
| card | object | yes | – |
| currency | string | yes | – |
| holdings | array | – | The player's stacks of any printing. Absent before sign-in |
| printing | object | yes | The printing asked about, or the newest |
| printings | array | yes | Every printing, newest set first, each with what the player owns of it |
| signed_in | boolean | – | Present, false, when the user has not signed in: the answer holds no copies, holdings or totals, so say nothing about what they own |
| totals | object | – | Absent before sign-in |
No examples provided.
cards_for_commander Cards for a commander ~494
Cards that belong in a commander deck (id or name; Commander, Duel Commander or Pauper Commander, with its commander set), in two lists titled by `title` ("For <commander>"; never call them recommendations). `played_with`: what the commander's tournament lists play, most played first — `share` 0–1 of its lists play the card, `share_elsewhere` of the format's other lists (a card far above its share elsewhere is this commander's own). Whenever you mention these counts, credit every source in `sources` by name with its link (TopDeck.gg always), and when `cedh` is true say they are cEDH tournament lists, not casual decks; `note` says it in one sentence. `known` false: under 10 lists a year, no counts. `on_theme`: the cards nearest the commander's rules text in its colours (`closeness` 0–1, not a verdict), for every commander, without the cards `played_with` holds. They are cards LIKE the commander — goblin makers for a goblin maker — and miss cards that work WITH it (the instants a spell-trigger commander wants): YOU judge which fit, and say so. Both lists are fitted to the deck: in its colour identity, legal in its format, not already in it; `owned` = the user's cards with free copies, `to_buy` = cheapest priced non-foil printing in `currency` (default USD), null when none is priced yet (the nightly price refresh prices it; `price_queued` is always false and `prices_queued` 0). Say `proxies` beside a card that has any, name every deck in `shared_with` (those copies are borrowed), and name the decks in `claimed_by` when `owned_claimed` > 0. `limit` per list and side, default 10, max 30. Read-only: it changes nothing and starts no work.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | yes | Deck id or name |
| limit | integer | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| commanders | array | yes | – |
| deck | object | yes | – |
| on_theme | object | yes | – |
| played_with | object | yes | – |
| prices_queued | number | yes | Always 0: this tool queues nothing; the nightly refresh prices a card with no price |
| title | string | yes | What the lists are called ("For <commander>"); never call them recommendations |
No examples provided.
check_legality Check a decklist's legality ~256
Whether a pasted decklist is legal, without saving it: in one format, or in every format when none is given. Takes the list as text ("4 Lightning Bolt" a line; a "Commander" and a "Sideboard" section, or *CMDR*, as the sites write them), any language Scryfall prints. Each verdict has legal and its issues (severity error or warning, code, message: size, copy limits, banned and restricted cards, commander and colour identity, the companion's condition). A list with a card in not_found is never called legal: the not_checked issue names those cards; say so. read_as names a card read in another language. Read from the card catalogue only; it works before the user signs in. For a deck already in Reliquary, deck_health reports more (missing cards, shared copies, proxies).
| Name | Type | Req | Description |
|---|---|---|---|
| decklist | string | yes | The decklist as text, at most 250 different cards |
| format | string | – | One format to judge; omitted, every format but casual. commander | pdh (Pauper Commander) | dc (Duel Commander) | standard | pioneer | modern | legacy | vintage | pauper | casual |
| Name | Type | Req | Description |
|---|---|---|---|
| commanders | array | yes | The commanders the list names, by their English names |
| companion | – | yes | The companion the list names, or null |
| ignored_lines | array | yes | Lines that were not read as cards (a maybeboard, a stray line) |
| main_cards | number | yes | Cards read in the main deck, the commanders among them |
| not_found | array | yes | Names the catalogue does not know, as typed: they were not checked, so say so |
| note | string | yes | – |
| read_as | array | yes | Names read in another language, each with its card: "Foudre → Lightning Bolt" |
| shared_names | array | yes | Names in another language several cards share: not checked; ask which card is meant |
| sideboard_cards | number | yes | Cards read in the sideboard, the companion among them |
| verdicts | array | yes | One a format: the format asked, or every format but casual |
No examples provided.
claim_from_collection Claim from collection ~267
Auto-match a deck's wants against the collection: free copies become non-shared staged allocations (real cards preferred over proxies). allow_shared:true additionally covers remaining needs with copies already allocated to OTHER decks, as explicitly shared allocations. Returns claimed / shared / missing. ALWAYS relay the shared list (with the other decks) and the missing list to the user. Every proxy it claims, owned or borrowed, is named in proxies_claimed (each claimed and shared entry carries is_proxy); proxy_warning, when not null, is one sentence: relay it to the user word for word. Claiming moves no real card: once the user has physically built the deck, sleeve_deck moves the claimed cards into it. On a tournament deck (deck.play) only real copies are claimed. They fill empty slots first, and each one past them releases one of the card's proxies (proxies_replaced, released: relay them). A released proxy that was sleeved is recorded back in "Unsorted": tell the user to take it out of the deck box and sleeve the real copy. This powers the "import deck → pull what I have → tell me what I lack" workflow.
| Name | Type | Req | Description |
|---|---|---|---|
| allow_shared | boolean | – | Default false |
| deck | string | yes | Deck id or name |
No output schema declared.
No examples provided.
collection_value Collection value ~160
Total collection value in `currency` (default USD), plus gain/loss versus recorded purchase prices (converted through ECB rates). include_proxies defaults to FALSE — proxies are excluded from value everywhere unless explicitly requested; say so when reporting. top_movers:true adds the biggest 7-day price movers among owned cards (needs nightly snapshots). The value over time is price_history.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| include_proxies | boolean | – | Default false |
| top_movers | boolean | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | yes | – |
| fx_date | string|null | yes | The day of the ECB rates used |
| include_proxies | boolean | yes | false: proxies are left out of every figure; say so |
| priced_cards | number | yes | – |
| purchase_known | object | yes | Gain or loss over the copies with a recorded purchase price only |
| top_movers | array | – | The biggest 7-day movers among owned cards, when asked |
| total_value | number|null | yes | – |
| unpriced_cards | number | yes | Copies with no price, left out of total_value |
No examples provided.
compare_trade Compare a trade ~358
Read-only: compares, and proposes or changes nothing (offer_swap is the tool that proposes a swap to a friend). Both directions of a trade with one player in ONE call: you_send (as match_wantlist) and you_get (as match_tradelist), each with its rows, card count and value in `currency` (default USD; CHF and EUR are what players at a table use), plus difference {amount, direction: you_send_more | you_get_more | even, unpriced_cards}. When unpriced_cards > 0 the gap leaves those cards out — say so, never call such a trade even. `with` is that player's handle ("@name") or one or two of their share links (their wantlist, their tradelist). A side they have not published is null and listed in not_published. This is everything that matches, NOT advice on which cards to trade and not an evened-out deal: present both lists and the gap, and let the players choose. Same disclosure duties as match_wantlist and match_tradelist: no proxy is ever offered; name every deck a copy breaks (copies[].breaks_decks, either side) and every copy in another language than asked. `with` names the player's handle also when reached by a wantlist or tradelist link.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| with | array | yes | One handle ("@name"), or one or two share links of the same player |
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | yes | – |
| difference | – | yes | Everything that matches on both sides, not an evened-out deal; null unless both sides are published |
| not_published | array | yes | – |
| note | string | yes | – |
| with | string|null | yes | The other player's handle ("@name"), also when reached by a wantlist or tradelist link; null for a deck share or a player without one |
| you_get | – | yes | null: they published no tradelist |
| you_send | – | yes | null: they published no wantlist |
No examples provided.
complete_deck_on_budget Complete deck on budget ~529
How to finish one deck (id or name) with `budget` to spend, in `currency` (default USD): the missing copies bought cheapest first while the budget lasts (`buy`, with `text` as "4 Card Name" lines for a shop), the copies that do not fit (`over_budget`, `over_by`), and the cards with no price yet (`no_price_yet`, left out of every total). A price is the cheapest non-foil printing among the priced ones, or the pinned printing's when the list pins one. Each over-budget card carries `owned_stand_ins`: cards the user owns with copies no deck claims outright, in the deck's colour identity, and `cheaper_to_buy`: cards whose cheapest price for every copy of the line fits what is left of the budget. With `stand_ins_by` "rules text" both come from the cards nearest by rules text (a nearer mana value and a more played card first), legal in the format; with "type and mana value" (no list for the card yet) they are mechanical filters only, still legal in the format, and `cheaper_to_buy` is empty; null for the commander, which gets none. Either way YOU judge whether one does the job. Say `proxies` beside a stand-in that has any, and name every deck in its `shared_with`: those copies are already borrowed. A line's `claimed_by_other_decks` means the user owns copies another deck claims: say so before they buy (claim_from_collection with allow_shared can borrow them). Name the cards in `printings_not_compared` as possibly cheaper: some of their printings have no price yet, and the nightly price refresh reaches every printing within a week (`prices_queued` is always 0: this tool queues nothing). Copies the user owns free (`claimable`) are not missing: run claim_from_collection first. Read-only: it changes nothing and starts no work. Relay `rate_missing` when present. `stand_ins_withheld`, when present, means the user's plan has no stand-ins: relay it once, as written.
| Name | Type | Req | Description |
|---|---|---|---|
| budget | number | yes | Money to spend, in `currency` |
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | yes | Deck id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| budget | number | yes | – |
| buy | array | yes | – |
| claimable | number | yes | Free copies not claimed: not missing, claim_from_collection takes them |
| complete | boolean | yes | – |
| currency | string | yes | – |
| deck | object | yes | – |
| left_over | number | yes | – |
| no_price_yet | array | yes | Left out of every total: say so |
| over_budget | array | yes | – |
| over_by | number | yes | – |
| prices_queued | number | yes | Always 0: this tool queues nothing; the nightly refresh reaches every printing within a week |
| printings_not_compared | array | yes | Priced from part of their printings: one not yet priced may be cheaper |
| rate_missing | string | – | Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it. |
| spend | number | yes | – |
| stand_ins_withheld | string | – | Present when the user's plan has no stand-ins: relay it once, as written |
| text | string | yes | – |
| total_estimated | number | yes | Every missing copy with a price; leaves out no_price_yet |
No examples provided.
crack_pack Crack pack ~172
Conversational bulk-add for opening boosters: adds cards with origin preset to "booster" and location defaulting to "Unsorted". Give one item per distinct card (name [+ set_code, collector_number] or scryfall_id) with quantity and optional finish (foil pulls!). Unresolvable names come back under "unresolved" — ask the user to clarify those. The pack is added in one write, and a name added as Scryfall's closest match or read in another language is listed under "inexact" with the card it became: tell the user.
| Name | Type | Req | Description |
|---|---|---|---|
| items | array | yes | – |
| location | string | – | Where the cards physically go (default "Unsorted") |
| set_code | string | – | Set the pack is from — applied to every item without its own set_code |
No output schema declared.
No examples provided.
create_deck Create deck ~292
Create a deck. Formats: commander | pdh (Pauper Commander) | dc (Duel Commander) | standard | pioneer | modern | legacy | vintage | pauper | casual (default casual). A location of kind "deck" with the same name is created automatically — sleeved cards physically live there. For commander, pdh and dc decks pass the commander as a card reference; it is added to the deck list automatically. A pair (Partner, "Choose a Background" + a Background, Doctor's companion + a Doctor) goes in commander + partner. A companion (Lurrus, Yorion, …) goes in companion: it is added to the sideboard (outside the 100 in a commander format, one of the 15 elsewhere), and deck_health checks its condition: a card that breaks it makes the deck not legal, and the issue names it. Never refused for the plan: a deck past the decks the user's plan keeps editable is made with its list and answers editable:false and plan_limit, which names the decks that take edits: relay it.
| Name | Type | Req | Description |
|---|---|---|---|
| commander | object | – | – |
| companion | object | – | The companion: a card with the Companion ability, kept in the sideboard |
| description | string | – | – |
| format | string | – | – |
| name | string | yes | – |
| partner | object | – | The second commander of a pair |
No output schema declared.
No examples provided.
create_location Create location ~52
Create a physical location. kind: binder | box | deckbox | shelf | other (deck locations are automatic).
| Name | Type | Req | Description |
|---|---|---|---|
| kind | string | – | – |
| name | string | yes | – |
| notes | string | – | – |
No output schema declared.
No examples provided.
create_share_link Create share link ~698
Create (or fetch the existing) public share URL for a wantlist, deck, or tradelist. kind "wantlist": the cards still MISSING from a deck — or from the personal wantlist when no deck is given. kind "deck": the full decklist with prices. By default it is the list alone — card names, any printing. show_printings:true adds the exact printing and finish of the copies in the deck (else the printing the list pins); show_proxies:true adds which copies are proxies. ASK the user which they want before sharing a deck that contains proxies or special printings. Passing either option for a deck that is already shared changes the existing link in place (same URL). kind "tradelist" with a location: every card physically there (typically "Trade Binder"), with condition and prices. kind "tradelist" WITHOUT a location: the user's tradelist by rule, what `rule` picks — unclaimed (every copy no deck claims), spares_card (all but one copy of each card; a claimed copy counts as the one kept) or spares_printing (all but one of each printing). Default spares_card; passing rule on the existing link changes it in place. Explain what the rule publishes and ask before publishing it. keep_open (spares rules only, default false): true keeps one copy of each card even from decks open to trade, so a card the user owns once is never offered; false offers every copy an open deck claims. It applies to every tradelist the user publishes. Every tradelist also carries the claimed copies of decks marked open_to_trade (update_deck) and copies decks borrow as shared, each naming the deck a trade breaks (breaks_decks: the deck names are public on the page). A tradelist never lists a proxy. The URL is PUBLIC — anyone holding it can view the list until it is revoked; tell the user this when sharing something sensitive. Minting is idempotent per target: sharing the same thing again returns the same URL. Only a new kind "deck" link counts toward the plan (PLAN_LIMIT past it); a wantlist or tradelist link never…
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | – | Deck id or name — required for kind "deck"; optional for "wantlist" (omit to share the personal wantlist) |
| keep_open | boolean | – | kind "tradelist" with no location only: under a spares rule, keep one copy of each card even from decks open to trade |
| kind | string | yes | – |
| location | string | – | Location id or name for a place's tradelist, e.g. "Trade Binder"; omit for the tradelist by rule |
| rule | string | – | kind "tradelist" with no location only: what the tradelist by rule offers |
| show_printings | boolean | – | kind "deck" only. Show the exact printings the owner plays. Default false on a new link; omitted keeps an existing link's setting. |
| show_proxies | boolean | – | kind "deck" only. Show which copies are proxies. Default false on a new link; omitted keeps an existing link's setting. |
No output schema declared.
No examples provided.
deallocate Deallocate ~96
Release an allocation (fully, or `quantity` copies of it). Sleeved copies physically return to return_location (default "Unsorted"). Identify the allocation by allocation_id, or by holding_id + deck.
| Name | Type | Req | Description |
|---|---|---|---|
| allocation_id | string | – | – |
| deck | string | – | Deck id or name (with holding_id) |
| holding_id | string | – | – |
| quantity | integer | – | – |
| return_location | string | – | – |
No output schema declared.
No examples provided.
deallocate_all Deallocate all ~82
DESTRUCTIVE: release EVERY allocation of a deck (holdings are never deleted; sleeved cards return to return_location, default "Unsorted"). Without confirm:true this returns a dry-run summary; repeat with confirm:true to execute.
| Name | Type | Req | Description |
|---|---|---|---|
| confirm | boolean | – | – |
| deck | string | yes | Deck id or name |
| return_location | string | – | – |
No output schema declared.
No examples provided.
deck_combos Combos in a deck ~452
The combos in a deck (id or name), any format, from Commander Spellbook's combo database (a copy refreshed with the card catalogue, not a live search). `in_list`: combos the deck's main list holds whole, most played first (up to 30; `in_list_total` says how many, counted among the 400 most played candidates read). `one_card_away`: combos the list misses one card of, most played first (up to 20; `more_one_card_away` when there are more), that card legal in the deck's format, in its colour identity and not in the deck: `missing.have` "owned" = the user owns a free copy (say `proxies` beside it when > 0, and name every deck in `shared_with`: those copies are borrowed), "to_buy" = its cheapest priced non-foil printing in `currency` (default USD; null when none is priced yet), and when `owned_claimed` > 0 name the decks in `claimed_by` that hold the user's copies. Each combo: its `cards` (`must_be_commander`: it works only from the command zone, so it counts only when that card leads the deck), `produces` (what it makes), `requires` (a kind of card it also needs, any one), `prerequisites` (the board it starts from), `mana_needed`, `steps`, `notes`, and `url`, its page on Commander Spellbook. Whenever you show a combo, credit Commander Spellbook by name with the link in `source`. `known` false: the combos are not loaded yet. Spellbook lists combos as written; check a combo's steps against the cards' text and rulings (card_detail) before you vouch for it. Changes nothing.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | yes | Deck id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| deck | object | yes | – |
| in_list | array | yes | – |
| in_list_total | number | yes | – |
| known | boolean | yes | False: the combos are not loaded yet |
| more_one_card_away | boolean | yes | – |
| one_card_away | array | yes | – |
| source | object | yes | Commander Spellbook: credit it by name with this link whenever a combo shows |
No examples provided.
deck_health Deck health ~194
Composed deck report: format legality (with per-issue detail: size, copy limits, sideboard, banned and restricted cards, commander and pairing rules, colour identity — pdh and dc by their own lists — and the companion's condition, naming each card that breaks it; deck.companion names the companion), missing cards, shared-copy disclosures (copies this deck borrows AND its own copies that other decks borrow — relay both), proxy count, and price-to-complete in `currency` (default USD). Proxies never affect legality but are always reported as a warning.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | yes | Deck id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| cards_wanted | number | yes | – |
| deck | object | yes | – |
| legality | object | yes | – |
| missing | array | yes | – |
| missing_cards | number | yes | – |
| price_to_complete | object | yes | – |
| proxy_count | number | yes | Claimed proxies: always say so |
| shared_copies | array | yes | Copies this deck borrows and its own copies other decks borrow: relay every line |
| sideboard_cards | number | yes | – |
No examples provided.
deck_stats Deck stats ~278
What a deck list is, for building: every row with its card facts (type, mana cost, mana value, colour identity, section, is_commander, is_companion), the mana curve of nonland cards (last bucket 7+), cards per type, coloured mana symbols against lands per colour, opening-hand land odds (exactly 0…7 lands in seven; two_to_four_lands), land_drops (a land every turn through turns 1…6, going first and second), and format legality. All figures are over the LIBRARY: the main deck without the commander(s) and without the sideboard. Probabilities are 0…1, hypergeometric — no mulligans, tutors or card draw; say so when quoting them. Optional `odds`: the chance of holding at least `want` (default 1) of a group of cards by `turn` (0 = the opening seven). Name the group by `cards` (names in the list) or by `type` (Land, Creature, …); on_the_play:true skips the first draw (two-player, going first). Reads the list only: it says nothing about which copies you own — use deck_status for that.
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | yes | Deck id or name |
| odds | object | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| cards | array | yes | – |
| deck | object | yes | – |
| legality | object | yes | – |
| note | string | yes | – |
| odds | object | – | Present when odds were asked |
| stats | object | yes | – |
No examples provided.
deck_status Deck status ~386
Per-card status of a deck list (deck id or name). deck.commanders names who leads it (one card, or a pair); deck.companion names its companion, or null; its row is the sideboard row with is_companion (outside the 100 in a commander format); deck.editable false: the deck is past the decks the user's plan keeps editable, and a change to it answers PLAN_LIMIT. sections counts main (commander included) and sideboard. Each row: its section, is_commander, wanted quantity and how it is covered — allocated (this deck's own copies), shared_in (copies deliberately shared from other decks — ALWAYS disclose these with which decks share them and where the cards physically are), claimable (free copies exist in the collection), missing. sleeved counts the allocated (own) copies that are physically in the deck; the other allocated copies are staged, still where they were. Row status is the strongest complete coverage: allocated > shared_in > claimable > missing. also_shared_with lists this deck's OWN copies that another deck also claims as shared: the two decks cannot be played at the same time — ALWAYS disclose these too, with the other deck and where the card physically is. A row with missing > 0 may carry held_elsewhere: copies the user DOES own that another deck claims (deck, where they are, is_proxy). Never call such a card "not owned": say it is in that deck, and that claim_from_collection with allow_shared:true would share it. deck.play tournament: a copy only a proxy covers counts as missing, and proxies_missing says how many of a row's missing copies the deck plays as proxies: say "you play a proxy; a tournament needs the real card". On a casual deck proxies count as covered.
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | yes | Deck id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| deck | object | yes | – |
| sections | object | yes | – |
| totals | object | yes | – |
| wants | array | yes | – |
No examples provided.
delete_deck Delete deck ~77
DESTRUCTIVE: delete a deck (id or name). Holdings are NEVER deleted — every allocation is released and sleeved cards physically return to "Unsorted". Without confirm:true this returns a dry-run summary only; repeat with confirm:true to delete.
| Name | Type | Req | Description |
|---|---|---|---|
| confirm | boolean | – | – |
| deck | string | yes | Deck id or name |
No output schema declared.
No examples provided.
draft_trade_post Draft a trade post ~288
Read-only: writes the TEXT of a trade list for the user to copy and post themselves (WhatsApp, Discord, anywhere). It posts nothing, sends nothing and publishes nothing (style: whatsapp | discord | text; default whatsapp): list "deck" (the deck's missing cards, linked by its wantlist link), "wantlist" (the personal wantlist's missing cards) or "tradelist" (what the user's published tradelists offer, linked by their handle). One line a card: count, name, the printing when the list pins one, a flag for a language other than English (one with no flag is written as its name), and on a tradelist each copy a deck of the user claims or plays shared named with that deck (lines[].breaks_decks): relay it. `cards` keeps only those names. Relay `text` as it is, in a code block or ready to copy. This tool NEVER publishes: when url is null no link is live yet — the note says which create_share_link call would publish it; ask the user before calling it, then call this again.
| Name | Type | Req | Description |
|---|---|---|---|
| cards | array | – | Only these card names (English); omit for the whole list |
| deck | string | – | Deck id or name, for list "deck" |
| list | string | yes | – |
| style | string | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| cards | number | yes | Copies the message lists |
| lines | array | yes | – |
| note | string | yes | – |
| publish | – | yes | With no live link: what create_share_link would publish to carry this post. Ask the user first |
| text | string | yes | The message to post, ready to copy: relay it as it is |
| url | string|null | yes | The live link the message ends with; null: none is published, and the text has no link |
No examples provided.
export_collection Export collection ~62
Export the whole collection as CSV text. format moxfield_csv (re-importable into Moxfield) or deckbox_csv. Large collections produce large text — offer the REST endpoint /api/v1/export/collection for downloads.
| Name | Type | Req | Description |
|---|---|---|---|
| format | string | yes | – |
| Name | Type | Req | Description |
|---|---|---|---|
| csv | string | yes | – |
No examples provided.
export_deck Export deck ~106
Export a deck (id or name) as plain decklist text: Commander section first when set (both of a pair), then a Companion section when the deck names one, then the "N Card Name" lines of the main deck, then a Sideboard section when there is one, the companion repeated there as Arena writes it (pinned printings keep their set/collector number). import_deck reads it back whole.
| Name | Type | Req | Description |
|---|---|---|---|
| deck | string | yes | Deck id or name |
| Name | Type | Req | Description |
|---|---|---|---|
| decklist | string | yes | – |
No examples provided.
find_substitutes Find substitutes ~517
Cards that could replace a target card, two ways. `similar`: the cards whose rules text is nearest the target's (precomputed over the whole catalogue, best first: nearest by text, with a nearer mana value, a more played card and one whose effects point at the same side ahead; `similarity` 0–1 is the text closeness alone, not a verdict), fitted to the deck when given — its colour identity (both commanders of a pair, else the target's), legal in its format, not already in it — as `owned` (the user's cards with free copies) and `to_buy` (cheapest priced printing in `currency`, null when none is priced; `owned_claimed` = copies the user owns that the decks in `claimed_by` claim in full: name them). Nearness is in the words, not in how a card plays with the deck: YOU judge which do the job, and say so. `similar.known` false means no list exists for the card yet. `candidates`: owned cards passing mechanical filters only (a shared primary type, cmc within cmc_window, default ±2, ignored for lands; optional price_ceiling per copy; with a deck, legal in its format). Both lists leave out a banned card, and a restricted one unless the row holds a single copy, since a swap keeps the row's count. Disclose free vs. claimed counts, say `proxies` beside a card that has any, and name every deck in `shared_with`. A card to buy with no price yet gets one from the nightly price refresh (`price_queued` is always false: this tool queues nothing). To make the swap, call replace_card with the row's want_id. Read-only: it changes nothing and starts no work; a target named by a name newer than the catalogue is looked up on Scryfall. Not on every plan: a PLAN_LIMIT answer says so.
| Name | Type | Req | Description |
|---|---|---|---|
| cmc_window | number | – | – |
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | – | Deck context (id or name) |
| limit | integer | – | – |
| price_ceiling | number | – | – |
| target | object | yes | The card to replace |
| Name | Type | Req | Description |
|---|---|---|---|
| candidates | array | yes | Owned cards passing mechanical filters only: judge functional similarity yourself |
| constraints | object | yes | – |
| note | string | yes | – |
| similar | object | yes | – |
| target | object | yes | – |
No examples provided.
fix_unresolved Fix unresolved ~130
Review imports that need attention. Without row_id: list unresolved rows (optionally for one job_id). With job_id, read_as also lists rows that named their card otherwise, each with the English card it was read as ("Blitzschlag" → Lightning Bolt): tell the user. With row_id + printing (scryfall_id, or name/set_code/collector_number): resolve that row to the given printing and import it with the original quantity/condition/price attributes.
| Name | Type | Req | Description |
|---|---|---|---|
| job_id | string | – | – |
| printing | object | – | – |
| row_id | string | – | – |
No output schema declared.
No examples provided.
generate_buylist Generate buylist ~184
Buylist of missing cards for one deck (id or name) or ALL decks (omit deck), cheapest-first, with a mass-entry friendly text block ("4 Lightning Bolt" per line) for Cardmarket/TCGplayer and an estimated total in `currency` (default USD). Per item: quantity, unit_price (non-foil), cheapest_printing ("SET number") and the decks that miss it. total_estimated leaves out the `unpriced_items`: give that count with the total.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| deck | string | – | Deck id or name; omit for all decks combined |
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | yes | – |
| items | array | yes | – |
| rate_missing | string | – | Present when CHF was asked and no CHF rate is stored: no CHF price could be given at all, the cards are not unpriced. Relay it. |
| text | string | yes | "4 Card Name" per line, for a shop's mass entry |
| total_estimated | number | yes | Leaves out unpriced_items: give that count with the total |
| unpriced_items | number | yes | – |
No examples provided.
import_batch Import batch ~471
Bulk-import collection rows that were parsed client-side from a CSV export: rows = the CSV rows as objects keyed by the file's own column headers. format: auto (default) recognises the app from the headers — ManaBox, Deckbox (also Delver Lens's Deckbox preset), Moxfield, Dragon Shield, Sorted, Archidekt, TCGplayer app, MTGGoldfish, TopDecked, Helvault, Deckstats, MTGStocks, CardCastle — and reads any other file by its column names (Name / Card Name, Set Code, Set Name, Collector Number, Quantity, Foil / Finish, Condition, Language, Scryfall ID, Purchase Price, Reg Qty + Foil Qty). Pass a format id only to overrule the detection; decklist (or decklist_text with no rows) reads plain decklist text into the collection. The response names the format it read (detected_format) and sets unchecked_layout when that layout was written without a real export file to test it: tell the user, and suggest they look over the first cards once the job is done. A Cardmarket export cannot be imported (it names cards only by Cardmarket's product number) and is refused with that reason. A card named in another language is read as its English card (fix_unresolved with job_id lists them as read_as). A set given by name only is matched to its set when the name is the one Scryfall uses; otherwise the card's newest regular printing is taken. Max 500 rows per call — pass the returned job_id in follow-up calls to continue the same job, then processing runs in the background in resumable chunks. ManaBox binders / Dragon Shield folders become locations automatically. Returns job status; when it finishes as needs_review, use fix_unresolved. A name matching no card exactly is looked up on Scryfall, at most 200 an import and 500 a day per player: a row past that is left for fix_unresolved, saying why.
| Name | Type | Req | Description |
|---|---|---|---|
| decklist_text | string | – | – |
| format | string | – | – |
| job_id | string | – | Continue a previously created job |
| rows | array | – | – |
| start | boolean | – | Begin background processing (default true) |
No output schema declared.
No examples provided.
import_deck Import deck ~466
Create a deck from pasted decklist text — the reliable path, ask for it first ("4 Lightning Bolt (2XM) 123" per line; Commander/Sideboard sections, "SB:" lines and *F* foil markers understood; any site's text export works: Moxfield, Archidekt, MTGGoldfish, MTGO, Arena). The link of a public Moxfield deck (moxfield.com/decks/…) is also accepted: it is asked for once, as a browser would. When Moxfield does not answer, the error says so — ask the user to open the deck on Moxfield → More → Export, copy the text, and retry with decklist_text. Sideboard cards land in the sideboard section; up to two commanders are kept as a pair. A companion (a Companion section, Moxfield's companion, *CMPN*) becomes the deck's companion, in the sideboard. Wants are stored oracle-level (any printing satisfies them). Card names may be in any language Scryfall prints ("4 Blitzschlag", "1 Foudre"): read_as lists each with the English card it was read as — tell the user. A foreign name several cards share is left unresolved with those cards named: ask which. Returns the deck, unresolved card names, ignored_lines (lines that were not a card: show them to the user, never guess) and notes to relay — e.g. a Commander list that came with a sideboard keeps it, and legality will flag it. Never refused for the plan: a deck past the decks the user's plan keeps editable is imported whole and answers editable:false and plan_limit, which names the decks that take edits: relay it. Typical next step: claim_from_collection to pull owned cards and report what is missing.
| Name | Type | Req | Description |
|---|---|---|---|
| commander | object | – | Commander override (else detected from the source) |
| companion | object | – | Companion override (else detected from the source) |
| decklist_text | string | – | Plain decklist text — preferred |
| format | string | – | – |
| name | string | – | Deck name override |
| url | string | – | Public Moxfield deck URL (alternative to decklist_text; Moxfield may block it) |
No output schema declared.
No examples provided.
invite_friend Invite friend ~141
An invite link for ONE player who is not on Reliquary yet, to bring them into the current user's trade circle. Relay `url` and `sentence` for the user to send (WhatsApp, a message): the sentence counts the cards the user's handle publishes and never names one. The link is single use and lasts 30 days: the first account made through it gets a circle request from the user waiting, which the new player accepts. A player already on Reliquary is added by handle (add_friend) instead. Needs the user's own handle (set_handle) and a free place in the plan's circle; a few links a day.
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
list_decks List decks ~60
List all decks with format, card counts and allocation counts. `editable` false: the deck is past the decks the user's plan keeps editable. It still reads, shares, exports and deletes, and a change to it answers PLAN_LIMIT: say so.
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| decks | array | yes | – |
No examples provided.
list_locations List locations ~35
All physical locations (binders, boxes, shelves, …) incl. each deck's auto-created location, with holding/card counts.
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| locations | array | yes | – |
No examples provided.
list_sets List sets ~245
Browse the Magic set catalog (cached from Scryfall, newest release first) with the user's per-set progress: card_count (total printings in the set), owned_printings (printings held as REAL cards) and proxy_only_printings (printings held only as proxies — physically present but not tournament-legal or tradeable, never counted as owned). Filter by set_type (core, expansion, masters, commander, draft_innovation, funny, starter, promo, token, …), name substring, or include_digital (default false). Use the returned set codes with set_completion. Owning another set's printing of a card does not count toward that set here.
| Name | Type | Req | Description |
|---|---|---|---|
| include_digital | boolean | – | Include digital-only sets (default false) |
| limit | integer | – | Default 100, max 1000 — the catalog has ~1000 sets; prefer filters |
| name | string | – | Substring of the set name, e.g. "ravnica" |
| offset | integer | – | – |
| set_type | string | – | Exact Scryfall set_type, e.g. "expansion", "core", "commander", "masters" |
| Name | Type | Req | Description |
|---|---|---|---|
| sets | array | yes | – |
No examples provided.
list_share_links List share links ~60
List every share link this user has minted — kind, what it points at (deck or location name), public URL, whether it is revoked, and for deck links what they show (show_printings, show_proxies: 1 or 0).
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| links | array | yes | Every link the user minted, newest first, revoked ones included |
No examples provided.
mark_circle_seen Mark circle seen ~74
Record that the current user has seen their trade circle's matches: the next match_circle (here or on the Trade page) marks as `new` only what came after. Call it once after showing the user match_circle's answer, never before and never in the background. marked_friends counts the friends whose match changed.
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
match_circle Match circle ~316
Every friend in the current user's trade circle at once, both directions: for each friend, you_send (their published wantlists' missing cards against the user's copies, free ones first, as match_wantlist) and you_get (their published tradelists against what the user's decks and wantlist miss, as match_tradelist), with values in `currency` (default USD) and the difference, as compare_trade. A side the friend has not published is null and in not_published. Each row has `new`: not there at the user's last recorded look; new_cards counts them per friend — lead with those. Once you have shown the user the matches, call mark_circle_seen so the next look marks only what came after (this tool itself never records a look). Each friend is matched alone, so one copy can show against several friends: say so when it does. Disclosure duties, as match_wantlist and match_tradelist (no proxy is ever offered): name every deck a copy breaks (copies[].breaks_decks: "trading this card breaks <deck>"), and every copy not in the language asked for (copies[].other_language). This is everything that matches, not advice on what to trade.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | yes | – |
| friends | array | yes | – |
| note | string | yes | – |
| totals | object | yes | – |
No examples provided.
match_tradelist Match tradelist ~278
What the CURRENT user could GET from another player: the cards in that player's tradelist that the user's decks or personal wantlist still miss. Takes their tradelist link (URL or bare token) or their handle ("@name": every tradelist they published). Each match says you_need, they_offer, wanted_by (the user's deck names, or "Personal wantlist") and copies[] with printing, finish, condition, language and unit_price in `currency` (default USD). A want that pins a printing matches that printing only. A proxy is never offered: the answer holds real cards only, and its proxy fields are always zero. copies[].breaks_decks names the other player's decks that claim or share the copy: say "trading this breaks their deck <name>". A row's lang is the language the user's list asks for; copies[].other_language marks a copy in another language: say "not the language asked for".
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| link | string | yes | Full share URL, bare token, or a handle written with its @ |
| Name | Type | Req | Description |
|---|---|---|---|
| matches | array | yes | What the user could get from the other player's tradelist |
| total | object | yes | – |
No examples provided.
match_wantlist Match wantlist ~325
What the CURRENT user could SEND another player: that player's missing cards against the current user's copies. Takes their shared wantlist or deck link (a /s/ or /w/ URL, or the bare token) or their handle ("@name": every wantlist they published). Free copies come first; where they run out, copies a deck of the user claims are offered too, after them. Each match has copies[]: printing, finish, condition, where it physically is, unit_price in `currency` (default USD; null = no price known, and unpriced_quantity says how many copies a row's value leaves out). A proxy is never offered: the answer holds real cards only, and its proxy fields are always zero. includes_shared / copies[].shared_with name decks of the user that SHARE that stack. copies[].breaks_decks names EVERY deck of the user that claims or shares the copy: for each, say "trading this card breaks your deck <name>" before any trade talk. A row's lang is the language the other player asked for; copies[].other_language marks a copy in another language: say "not the language asked for".
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| token | string | yes | Full share URL, bare token, or a handle written with its @ |
| Name | Type | Req | Description |
|---|---|---|---|
| matches | array | yes | What the user could send: free copies first, then copies a deck of the user's claims (named in breaks_decks); never a proxy |
| total | object | yes | – |
No examples provided.
move_holding Move holding ~93
"The card is physically HERE now." Moves a holding (stack) to a location (id or name; unknown names are created). Allocation statuses reconcile automatically: sleeved allocations into decks elsewhere drop to staged; staged allocations into the deck living at the target location become sleeved. Report the status_changes to the user.
| Name | Type | Req | Description |
|---|---|---|---|
| holding_id | string | yes | – |
| location | string | yes | Target location id or name |
No output schema declared.
No examples provided.
my_circle My circle ~147
The current user's trade circle: friends, requests_received (waiting for the user: accept_friend or remove_friend), requests_sent (waiting for the friend), each by handle with the date. places_taken counts friends and requests sent against cap (null = no limit). handle is the user's own, null when they have none. invites: the invite links the user made (invite_friend), each for one player, with its state: open, waiting (a newcomer signed up and has not accepted yet: they have no handle, so they are told here, not under requests_sent), accepted, closed or expired. An open or waiting link takes a place against cap; cancel_invite gives it back.
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| cap | number|null | yes | Friends the account's plan holds, requests sent included; null = no limit |
| friends | array | yes | – |
| handle | string|null | yes | The user's own handle; null when they have none (they need one to add friends) |
| invites | array | yes | Invite links the user made (invite_friend), newest first: the last 30 days, and any still waiting. Open and waiting ones take a place against cap |
| places_taken | number | yes | Friends, requests sent and open invite links, counted together against cap |
| requests_received | array | yes | Waiting for the user: accept_friend or remove_friend |
| requests_sent | array | yes | Waiting for the friend to accept |
No examples provided.
my_swaps My swaps ~194
The current user's swaps with friends: waiting_for_you (proposed to the user: approve or decline with answer_swap), waiting_for_friend (proposed by the user: they may withdraw it), and answered in the last 30 days. Each swap: you_give and you_receive with cards, value in `currency` (default USD) and lines. Disclosure duties: name every deck of the user's a copy they give breaks (lines[].breaks_decks), and on an open swap every claim the yes would release (lines[].would_release). The friend's deck names are never shown. An open swap past expires_at reads expired.
| Name | Type | Req | Description |
|---|---|---|---|
| currency | string | – | Display currency. USD/EUR come from Scryfall; CHF is always EUR × the stored ECB rate. A response that carries `rate_missing` could not price in CHF at all: tell the user that, not that the cards hav… |
| Name | Type | Req | Description |
|---|---|---|---|
| answered | array | yes | Approved, declined, withdrawn or expired, the last 30 days |
| currency | string | yes | – |
| note | string | yes | – |
| waiting_for_friend | array | yes | Proposed by the user: the friend answers; the user may withdraw |
| waiting_for_you | array | yes | Proposed to the user: approve or decline (answer_swap) |
No examples provided.
offer_swap Offer swap ~283
Propose a swap to a FRIEND in the trade circle, from match_circle's rows with that friend: `send` picks rows of you_send and `get` rows of you_get, each by card name and count (a card with several rows: narrow with printing and lang, as the row shows them). Copies go as the match deals them: free ones first, then a deck's copy, never a proxy. Nothing outside the match can be added. `add_to` names, for a card the user GETS, the deck of theirs that claims it once the swap is approved: only on the user's say-so, never by default. Nothing moves until the friend approves; it expires after 14 days, and the user can withdraw it (answer_swap). Before calling, show the user both sides, their values, and every deck of theirs a copy they send breaks (breaks_decks in match_circle), and ask. The answer is the swap as my_swaps shows it.
| Name | Type | Req | Description |
|---|---|---|---|
| add_to | array | – | Cards the user gets that a deck of theirs claims on the yes, as the user ticked them |
| get | array | – | Rows of you_get to receive, with counts |
| send | array | – | Rows of you_send to send, with counts |
| with | string | yes | The friend's handle, with its @ |
No output schema declared.
No examples provided.
personal_wantlist Personal wantlist ~101
The personal wantlist: cards the user wants that belong to no deck (add with add_wants without `deck`, change or cut a row with update_want). Per row: wanted, claimable (free copies the user already holds — those are not missing) and missing. Only the `missing` copies appear on the shared wantlist (create_share_link kind "wantlist" without deck) and in match_tradelist / compare_trade.
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| totals | object | yes | – |
| wants | array | yes | – |
No examples provided.
How do I install the Reliquary MCP server?
Reliquary is a hosted endpoint at https://reliquary.gg/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.
remote · reliquary.gg
claude mcp add --transport http gg-reliquary-reliquary 'https://reliquary.gg/mcp'
What is the Reliquary MCP server?
Reliquary is an MCP server listed in the public MCP registry as gg.reliquary/reliquary. Your Magic: The Gathering collection, decks and trades, with every shared copy disclosed. This page covers its hosted endpoint (https://reliquary.gg/mcp).
Is the Reliquary MCP server safe to use?
Reliquary scores 78 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.
What tools does the Reliquary MCP server expose?
Reliquary exposes 74 tools: search_collection, add_holdings, update_holding, remove_holding, crack_pack, and 69 more. Their descriptions and schemas cost roughly 16,663 tokens of context every time the server is loaded.
Does the Reliquary MCP server require authentication?
Yes. Reliquary asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.
Is the Reliquary MCP server still maintained?
Reliquary is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.
What did VerifyMCP test on the Reliquary MCP server?
VerifyMCP ran 14 checks on Reliquary, covering TLS certificate, Authorization, HTTPS, HSTS header and 10 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.