Schema reference

Generated from the live schema, so it always matches the API. Send queries to POST https://raritydb.com/graphql with your key; see Authentication. The raw schema is at /schema.graphql.

Query (entry points)

Pokémon TCG data: species, sets, cards and printings. Start with search or resolveId if you have a name or another system's ID.

assessCondition ConditionAssessment!
Estimate a card's condition from photos: centering and edge whitening are measured, visible damage (creases, dents, scratches, stains) is reported with locations, and they combine into a grade range with what the photos can't show. Pass the front, and the back for a narrower range, as base64, a data URL or an https URL; the card must be at least 1000 px wide in the photo, out of its sleeve if possible.
Arguments
  • front: String!
  • back: String
card Card
One card by code, e.g. swsh3-136 or asia:SV2a-006.
Arguments
  • code: String!
cards CardConnection!
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
  • filter: CardFilter
  • orderBy: CardOrder
checkAuthenticity AuthenticityCheck!
Look for signs that a card is fake. The card is identified, its printed numbers and names are compared with our catalog, and the photo with a scan of the real card (fonts, symbols, spelling, colours, finish, and the back if sent). Returns red flags and a verdict of LIKELY_FAKE, NO_RED_FLAGS or CANT_TELL; it never says a card is genuine. Pass the front (and ideally the back) as base64, a data URL or an https URL.
Arguments
  • front: String!
  • back: String
identifyCard Identification!
Identify a card, and its exact printing where the photo shows it (1st Edition, Shadowless, reverse holo, stamps), from a photo. Pass the image as base64, a data URL, or an https URL (JPEG, PNG or WebP; at most 10 MB; at least 600 px on the short edge). An optional second photo tilted under a light helps tell holo from reverse.
Arguments
  • image: String!
  • tiltedImage: String
identifyCards BatchIdentification!
Identify every card in one photo of several: a spread on a table or a binder page (up to 20 cards). Cards are found by their outlines and returned in reading order with where each is in the photo. For a binder page whose cards touch, pass grid (e.g. "3x3") to split the photo evenly instead. Each identified card counts as one photo check; cards past your remaining checks come back with an error instead of an identification.
Arguments
  • image: String!
  • grid: String Rows x columns, e.g. 3x3 for a 9-pocket page.
node Node
Fetches an object given its ID.
Arguments
  • id: ID!
resolveId [Entity!]!
Look up a record by another system's ID. Sources: tcgdex, pokemontcg.io, tcgplayer (product id), cardmarket (idProduct). Marketplace ids can map to several printings.
Arguments
  • source: String!
  • value: String!
sealedProducts SealedProductConnection!
Sealed products, newest first.
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
  • setCode: String
  • kind: String See SealedProduct.kind for values.
  • region: Region
  • name: String Case-insensitive substring.
search [Entity!]!
Fuzzy name search across species, sets and cards (any spelling close to the query), best matches first.
Arguments
  • query: String!
  • limit: Int
series [Series!]!
All series, oldest first.
set Set
One set by code, e.g. sv03.5 or asia:SV2a.
Arguments
  • code: String!
sets SetConnection!
Sets, newest first.
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
  • region: Region
  • series: String Series slug, e.g. sv.
  • digital: Boolean false = physical sets only; true = TCG Pocket only.
slabVerification SlabVerification!
Where to verify a graded slab's cert number (PSA, CGC, BGS, SGC, TAG) and whether the number fits the grader's format. identifyCard fills this in from a photo of the slab label.
Arguments
  • grader: String!
  • cert: String!
species Species
One species by Pokédex number or slug.
Arguments
  • nationalDex: Int
  • slug: String
speciesList SpeciesConnection!
Species in Pokédex order.
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
  • generation: Int
  • type: String Matches the default form's types, e.g. fire.
viewer Viewer
Your account: plan, limits and usage.

Attack

cost [String!]!
Energy types required, one entry per Energy.
damage String
Printed damage, e.g. "90", "30+", "20×".
effect String
name String!

AuthenticityCheck

Red flags that a card is fake, from photos. Never says a card is genuine.

card Card
The real card the photo was compared with.
checked [String!]!
What was compared and matched the real card.
disclaimer String!
identificationStatus String!
MATCH, AMBIGUOUS or NO_MATCH (see identifyCard).
model String!
notChecked [String!]!
notes [String!]!
Weak observations the lighting or the photo could explain (e.g. a colour shift); never decide the verdict.
physicalChecks [String!]!
Checks a photo can't do, for the holder of the card.
redFlags [RedFlag!]!
Strongest first. Only strong and medium ones.
timingsMs JSON!
verdict AuthenticityVerdict!

BatchIdentification

Every card found in one photo of several (a spread or a binder page), identified one by one.

cards [BatchIdentificationCard!]!
detected Int!
How many cards were found.
foundBy String!
outlines (cards found by their edges) or grid (the photo split evenly).
hints [String!]!

BatchIdentificationCard

One card in the photo: its identification, or why it has none.

box PhotoBox!
column Int!
error String
identification Identification
Null when error says why (photo quota, too small).
index Int!
Position in reading order, from 0.
row Int!

Card

A card as printed in one set. Its printings are the collectible variants (normal, reverse holo, stamped…).

abilities [CardAbility!]!
attacks [Attack!]!
code String!
Our card id: TCGdex's id (e.g. swsh3-136), prefixed with asia: for Asian cards.
effect String
Rules text for Trainer and Energy cards.
englishName String
For Japanese and other Asian cards: the English name, from TCGplayer's English listing, or (englishNameSource DERIVED) from the Pokémon's name plus the card's suffix. Null when unknown.
englishNameSource String
tcgplayer or derived.
evolvesFrom String
externalIds [ExternalId!]!
IDs in other systems, e.g. pokemontcg.io (sv3-125).
flavorText String
hp Int
id ID!
ID of the object.
illustrator String
image Image
Card scan.
legalities Legalities!
localizedNames [LocalizedName!]!
name String!
Arguments
  • locale: String Defaults to the card's primary language.
number String!
Collector number as printed.
printings [Printing!]!
productImage ExternalImage
TCGplayer's photo of the card, hosted by TCGplayer (linked, not copied). Mainly useful for Asian cards with no scan in `image`; show its credit.
rarity String
regulationMark String
resistances [TypeModifier!]!
retreatCost Int
set Set!
species [CardSpeciesLink!]!
stage String
Basic, Stage1, Stage2, VMAX…
subtypes [String!]!
e.g. EX, V, VMAX, Item, Supporter, Special.
supertype Supertype!
types [String!]!
weaknesses [TypeModifier!]!

CardAbility

effect String
name String!
type String
e.g. Ability, Poké-Power, Poké-Body.

CardReading

What the vision model read on the card. Null means it couldn't read that clearly.

copyrightYears String
firstEditionStamp Boolean!
foilPattern String
holoArea String!
artwork (holo), whole_card (reverse holo), none, unknown.
isTradingCard Boolean!
language String
legibility Float!
name String
notes String
number String
otherStamps [String!]!
printedTotal String
regulationMark String
setCode String
shadowless Boolean
Base Set era only.
slabCert String
slabGrade String
slabGrader String
Set when the card is in a graded slab.

A species on a card. Tag-team cards link several; cameo links are Pokémon that only appear in the artwork.

cameo Boolean!
form Form
Set when the card is a specific form, e.g. Alolan Vulpix or Mega Charizard X ex.
species Species!

Centering

bordersMm JSON!
Measured border width per side in mm (null where not measurable).
leftRight CenteringRatio
Null when there's no clear, even border to measure.
topBottom CenteringRatio

CenteringLimit

The best grade a grader's published centering limits allow for the measured centering.

grade String
e.g. 9, Gem Mint 10. Null when the grader publishes no limit this low.
grader String!
note String
value Float

CenteringRatio

Border widths on one axis as percentages, e.g. 57 / 43 (left / right or top / bottom).

display String!
first Float!
Left or top share.
second Float!
Right or bottom share.
uncertainty Float!
± in percentage points.

ConditionAssessment

A condition estimate from photos: measured centering and whitening, visible defects, and the grade range they allow.

back ConditionSide
cannotAssess [String!]!
What these photos can't show.
centeringLimits [CenteringLimit!]!
confidence String!
high, medium or low: how narrow the range is.
defects [ConditionDefect!]!
disclaimer String!
front ConditionSide!
gradeRange GradeRange!
limitingFactors [String!]!
What holds the grade down, worst first.
model String!
timingsMs JSON!

ConditionDefect

Damage the vision model saw (only those at least 50% likely).

confidence Float!
kind String!
crease, dent, indentation, scratch, print_line, stain, writing, whitening, edge_chip, corner_wear.
location String!
severity String!
minor, moderate or major.
side String!

ConditionSide

What was measured on one side of the card.

cardShortEdgePx Int!
The card's width in the photo.
centering Centering!
glareFraction Float!
sharpness Float!
wear [Wear!]!

ExpectedValue

What opening this is worth on average at today's Cardmarket prices. Read `caveats`: EV ignores bulk selling costs and assumes cards of a rarity are equally likely.

asOf ISO8601Date
caveats [String!]!
currency String!
fxDate ISO8601Date
When converted: the date of that rate.
fxRate Float
When converted: units of `currency` per euro used (European Central Bank reference rate).
lines [ExpectedValueLine!]!
priceCoverage Float
Share of the set's cards (in the lines) that have a price, 0–1.
samplePacks Int
sources [String!]!
total Float
Null when it can't be computed; `caveats` says why.
unit String!
pack or product.

ExpectedValueLine

cardCount Int
contribution Float
quantity × probability × unitValue. Null when nothing in the line has a price.
label String!
A rarity, or for sealed products a pack/card/product.
pricedCount Int
How many of cardCount have a price today.
probability Float!
quantity Int!
slot String!
unitValue Float
Mean price of the cards in this line (or value of one pack/product).

ExternalId

This record's identifier in another system. Pass it to resolveId to come back here.

source String!
tcgdex, pokemontcg.io, tcgplayer or cardmarket.
value String!

ExternalImage

A product photo hosted by a marketplace. We link to it and don't host or license it: show it with its credit and a link to pageUrl, or not at all.

credit String!
Show this next to the image.
pageUrl String!
The marketplace's product page.
source String!
Who hosts it, e.g. tcgplayer.
thumbnailUrl String!
About 200 px wide.
url String!
Full-size image (about 1000 px).

Form

A battle form of a species with its own types and stats, e.g. vulpix-alola.

abilities [String!]!
artwork Image
Official artwork. Currently not served (url is null).
baseStats [Stat!]!
height Int
Decimetres.
isDefault Boolean!
kind FormKind!
name String!
PokéAPI identifier, e.g. vulpix-alola, charizard-mega-x.
species Species!
types [String!]!
weight Int
Hectograms.

GradeRange

Best and worst grade the photos allow, on the common 1–10 card grading scale.

high Float!
low Float!
scale String!

Identification

The result of identifying a card from a photo.

candidates [IdentificationCandidate!]!
Ranked alternatives with the evidence for each.
card Card
The best match (null for NO_MATCH).
confidence Float
hints [String!]!
What would settle an ambiguous result (e.g. tilt to show the holo).
model String!
Vision model that read the card.
printing Printing
The exact printing, when the visible cues leave only one.
printings [Printing!]!
Printings of the card still consistent with the photo.
quality PhotoQuality!
reading CardReading!
slab SlabVerification
When the card is in a graded slab: where to verify its cert.
status IdentificationStatus!
timingsMs JSON!

IdentificationCandidate

card Card!
imageSimilarity Float
Cosine similarity to the card's reference scan; null if it wasn't among the nearest.
reasons [String!]!
score Float!
0–1, combining what was read with image similarity.
textScore Float!
How well the printed text (number, set size, set code, name, language) matches.

Image

kind String!
large (card scan), logo, symbol or artwork.
source String!
Where the image originally came from.
url String
Null when this image is not currently served.

ImportError

message String!
row Int!

ImportMapping

field String!
order_id, sold_on, title, sku, set_name, number, quantity, item_price, shipping_charged, shipping_cost, fees, buyer or event.
headers [String!]!

Legalities

Tournament format legality.

expanded Boolean
standard Boolean

LocalizedName

locale String!
Language code, e.g. en, fr, ja, zh-tw.
name String!

MarketQuote

A price from a provider you queried with your own key. Quotes cover the whole TCGplayer product, so check `printing`.

asOf ISO8601DateTime
condition String
Raw condition, e.g. Near Mint. Null for graded quotes.
currency String!
grade String
grader String
PSA, BGS, CGC or SGC for graded sales.
price Float
printing String
Provider's printing label, e.g. Normal, Reverse Holofoil, Holofoil.
provider PriceProvider!
salesCount Int
Number of sales behind a graded price.

A link to look up live prices yourself. We do not fetch or store these marketplaces' prices.

exact Boolean!
True when the link goes to this exact product; false when it is a search.
marketplace String!
tcgplayer, cardmarket, ebay_sold or pricecharting.
url String!

Mutation

Manage price alerts and the webhook endpoints they post to, and your Pullbook seller ledger.

addExtraCost [PullbookItem!]!
Spread one bill (a grading submission, say) evenly over items, to the cent.
Arguments
  • itemIds: [ID!]!
  • amount: Float!
  • note: String
addPulls PullbookPurchase!
Add what came out of a purchase: cards by code, and a count of bulk cards. fromItemId puts them inside one of the purchase's sealed items (opening one unit of it). The cost is re-split.
Arguments
  • purchaseId: ID!
  • pulls: [PullInput!]
  • bulk: Int
  • fromItemId: ID
createEvent PullbookEvent!
A stream or card show to group sales by.
Arguments
  • name: String!
  • kind: PullbookEventKind!
  • heldOn: ISO8601Date!
  • cost: Float
createPriceAlert PriceAlert!
Watch a printing's Cardmarket trend price. Name the card by code and, when it has several printings, the printing by key (see Card.printings). The printing must have a Cardmarket product.
Arguments
  • cardCode: String!
  • printingKey: String
  • condition: PriceAlertCondition!
  • threshold: Float!
  • webhookEndpointId: ID!
createPullbookCheckout String!
A Stripe Checkout link for a paid plan. Open it in a browser to pay; your plan changes once Stripe confirms.
Arguments
  • plan: String! pro, dealer or founding.
  • interval: String! month or year (founding is yearly only).
createPurchase PullbookPurchase!
Log something you bought. SEALED needs sealedProductId (a SealedProduct id); its units become an item you can open. Amounts are in your ledger's currency.
Arguments
  • kind: PullbookPurchaseKind!
  • name: String Defaults to the sealed product's name.
  • purchasedOn: ISO8601Date!
  • price: Float Required unless costUnknown.
  • costUnknown: Boolean You don't know what you paid (cards you've had for years): amounts are 0, items count toward holdings' value but not gain, and tax lots say so.
  • shipping: Float
  • tax: Float
  • sealedProductId: ID
  • quantity: Int
  • source: String
  • notes: String
createSale PullbookSale!
Record a sale. Fees come from the channel's schedule unless you pass fees. Counts toward your plan's monthly sales.
Arguments
  • channel: PullbookChannel!
  • soldOn: ISO8601Date!
  • lines: [SaleLineInput!]!
  • shippingCharged: Float
  • shippingCost: Float
  • fees: Float
  • eventId: ID
  • externalOrderId: String
  • buyer: String
  • notes: String
createWebhookEndpoint WebhookEndpointWithSecret!
Register an https URL to receive events. Returns the signing secret, shown only this once.
Arguments
  • url: String!
deleteEvent ID!
Delete a stream or show (its sales are kept). Returns its id.
Arguments
  • id: ID!
deleteItem ID!
Remove an unsold item. Returns its id.
Arguments
  • id: ID!
deletePriceAlert ID!
Stop an alert. Returns its id.
Arguments
  • id: ID!
deletePurchase ID!
Delete a purchase and its items (not once something from it has sold). Returns its id.
Arguments
  • id: ID!
deleteSale ID!
Delete a sale; its items go back in stock. Returns its id.
Arguments
  • id: ID!
deleteWebhookEndpoint ID!
Delete an endpoint and the alerts that post to it. Returns its id.
Arguments
  • id: ID!
finishImport PullbookImport!
Map the columns of an import that is NEEDS_MAPPING, and run it.
Arguments
  • id: ID!
  • mapping: [ImportMappingInput!]!
importSales PullbookImport!
Import a sales export (CSV text, up to 2 MB / 5,000 rows). Columns are found by name for Whatnot, eBay and TCGplayer exports, or by a mapping you pass (or saved from an earlier file with the same headers). Re-importing is safe.
Arguments
  • csv: String!
  • channel: PullbookChannel!
  • filename: String
  • mapping: [ImportMappingInput!]
openItem PullbookItem!
Open one unit of a sealed item. Returns the opened unit.
Arguments
  • id: ID!
pullbookBillingPortal String!
A Stripe link to change or cancel your paid plan. Open it in a browser.
resolveSaleLine PullbookSaleLine!
Settle a sold line: itemId sells that inventory item; costBasis says it wasn't from your ledger (and what it cost); unmatch: true puts its item back and the line back in review.
Arguments
  • id: ID!
  • itemId: ID
  • costBasis: Float
  • unmatch: Boolean
  • cardCode: String Say which card a REVIEW line is (with itemId, then sell that copy).
rotateWebhookSecret WebhookEndpointWithSecret!
Replace an endpoint's signing secret. The old one stops working immediately.
Arguments
  • id: ID!
sendTestWebhook WebhookDelivery!
POST a signed ping event to an endpoint now (no retries) and return how it answered.
Arguments
  • id: ID!
updateEvent PullbookEvent!
Arguments
  • id: ID!
  • name: String
  • kind: PullbookEventKind
  • heldOn: ISO8601Date
  • cost: Float
updateItem PullbookItem!
Set an item's value for splitting cost, its condition or grade, or what was spent on it alone.
Arguments
  • id: ID!
  • valueOverride: Float Per unit, on the Cardmarket (€) scale. Pass null to use the market price.
  • clearValueOverride: Boolean true: go back to the market price (same as valueOverride: null).
  • extraCost: Float
  • extraCostNote: String
  • condition: String
  • grade: String
updatePullbookSettings Pullbook!
Change your ledger's currency (only before you've logged purchases) or the bulk card weight, or note which paid plan you'd like (PRO, DEALER or FOUNDING). To buy one, use createPullbookCheckout.
Arguments
  • currency: String
  • bulkWeight: Float
  • upgradeInterest: String
updatePurchase PullbookPurchase!
Edit a purchase. Changing what it cost re-splits the cost over unsold items.
Arguments
  • id: ID!
  • name: String
  • purchasedOn: ISO8601Date
  • price: Float Ignored while the purchase is costUnknown; send costUnknown: false with it.
  • shipping: Float
  • tax: Float
  • costUnknown: Boolean
  • source: String
  • notes: String

PackSlot

count Int!
slot String!
common, uncommon, reverse or rare.

PhotoBox

Where a card is in the photo, as fractions (0–1) of the photo's width and height from the top left.

height Float!
width Float!
x Float!
y Float!

PhotoQuality

cardFound Boolean!
Whether the card's outline was found and straightened.
glareFraction Float!
Share of the card that is blown-out highlight.
sharpness Float!
Variance of the Laplacian; under ~100 is blurry.
shortEdgePx Int!

Price

A daily price snapshot. Cardmarket prices one product per card; reverse-holo printings report its holo columns.

asOf ISO8601Date!
attribution String!
Show this wherever the price is displayed.
avg Float
avg1 Float
avg30 Float
avg7 Float
currency String!
fxDate ISO8601Date
When converted: the date of that rate.
fxRate Float
When converted: units of `currency` per euro used (European Central Bank reference rate).
low Float
source PriceSource!
trend Float

PriceAlert

Watches one printing's Cardmarket trend price (EUR) and POSTs to a webhook endpoint when the condition is met. Checked once a day after Cardmarket's daily price guide is imported.

card Card!
condition PriceAlertCondition!
createdAt ISO8601DateTime!
id ID!
lastTriggeredOn ISO8601Date
printing Printing!
threshold Float!
EUR for TREND_ABOVE / TREND_BELOW; percent for CHANGE_ABOVE_PERCENT.
webhookEndpoint WebhookEndpoint!

Printing

One collectible variant of a card: the unit marketplaces sell and price.

card Card!
cardmarketProductId Int
finish String!
normal, holo, reverse, firstEdition…
foil String
Foil pattern, e.g. cosmos.
id ID!
ID of the object.
key String!
Stable variant id within the card.
marketPrices [MarketQuote!]!
Live USD prices from a provider you have a key for (see PriceProvider). Results are cached for 6 hours per key.
Arguments
  • provider: PriceProvider!
price Price
Latest daily price from Cardmarket, in euros unless you ask for another currency (converted at the ECB rate for its date). For live US marketplace prices, follow marketplaceLinks.
Arguments
  • source: PriceSource
  • currency: Currency
priceHistory [Price!]!
Arguments
  • source: PriceSource
  • from: ISO8601Date
  • to: ISO8601Date
  • currency: Currency Each day converted at that day's rate.
size String
stamps [String!]!
subtype String
Print run or variation: unlimited, shadowless, 1999-2000-copyright, or a known misprint (e.g. missing-expansion-symbol).
tcgplayerProductId Int

PullRate

Per-pack odds of pulling a card of this rarity, from a published opening study.

ci String
Published confidence interval, e.g. ±0.36%.
observedOn ISO8601Date
odds String
As published, e.g. "1 in 81".
pattern String
Set for reverse-holo patterns (pokeball, masterball): odds of that pattern rather than a rarity.
probability Float!
Chance per pack, 0–1.
rarity String!
Matches Card.rarity.
samplePacks Int
Packs opened in the study (published as a floor, e.g. "more than 3,500").
slot String!
rare, reverse_1 or reverse_2 (the two reverse-holo slots, either of which can upgrade).
source String!
sourceUrl String!

Pullbook

Your Pullbook ledger: what you bought, what came out of it, and what it cost you.

bulkWeight Float!
What one bulk card weighs when cost is split, on the Cardmarket (€) scale.
currency String!
Every amount in the ledger is in this currency.
events [PullbookEvent!]!
Streams and shows, newest first.
holdings PullbookHoldings!
What you hold, what it cost and what it's worth at market prices.
import PullbookImport
One upload, to check on a running import.
Arguments
  • id: ID!
imports [PullbookImport!]!
Sales exports you've uploaded, newest first.
inventory [PullbookItem!]!
Items not sold or opened, most expensive first.
plan String!
purchase PullbookPurchase
Arguments
  • id: ID!
purchases [PullbookPurchase!]!
Arguments
  • kind: PullbookPurchaseKind
report PullbookReport!
What you made, grouped; only settled sales count.
Arguments
  • groupBy: PullbookReportGroup!
  • year: Int Sales in this calendar year; all time when left out.
reviewQueue [PullbookSaleLine!]!
Sold lines waiting to be matched to your inventory.
sale PullbookSale
Arguments
  • id: ID!
sales [PullbookSale!]!
Newest first.
Arguments
  • channel: PullbookChannel
  • from: ISO8601Date
  • to: ISO8601Date
  • eventId: ID
  • needsReview: Boolean
salesPerMonthLimit Int
null = unlimited.
salesThisMonth Int!
Sales recorded this calendar month (what the plan limit counts).
taxLots [PullbookTaxLot!]!
Every item sold in a year, oldest first (paid plans): not tax advice. Sales with an item waiting in review aren't included (see taxLotsInReview).
Arguments
  • year: Int!
taxLotsInReview Int!
Sales that year left out of taxLots because an item is waiting in review.
Arguments
  • year: Int!
upgradeInterest String
The paid plan you said you're interested in.

PullbookEvent

A stream or card show. Its profit is its sales' net, minus their cost basis, minus what the event cost.

cost Float!
costBasis Float!
heldOn ISO8601Date!
id ID!
kind PullbookEventKind!
name String!
net Float!
profit Float!
Settled sales' net − their cost basis − the event's cost. Sales still in review aren't counted until they're settled.
salesCount Int!
salesInReview Int!

PullbookHolding

Something you still hold, at market value in your ledger's currency.

asOf ISO8601Date
The price's date.
cost Float
What it cost you (costBasis); null when its purchase is costUnknown.
costUnknown Boolean!
gain Float
value − cost; null without both.
item PullbookItem!
value Float
Cardmarket's trend (else average) times quantity, converted from euros at the rate for the price's date; null without a price or a rate.

PullbookHoldingDay

date ISO8601Date!
value Float!
What today's holdings were worth that day.

PullbookHoldingGroup

kind String!
sealed or singles (cards and bulk).
quantity Int!
value Float!

PullbookHoldings

What you hold, what it cost and what it's worth today. Market values are estimates, not offers.

asOf ISO8601Date
The newest price date.
costUnknownQuantity Int!
costUnknownValue Float!
Value of items from purchases marked costUnknown (in value, never in gain).
currency String!
gain Float!
On items with both a value and a known cost.
gainPercent Float
gain as a percent of what those items cost.
groups [PullbookHoldingGroup!]!
history [PullbookHoldingDay!]!
Value of today's holdings on each day with prices.
Arguments
  • days: Int
paid Float!
What you paid for items with a known cost.
ratesLoaded Boolean!
False until exchange rates are loaded: values are null and totals 0.
rows [PullbookHolding!]!
Most valuable first.
Arguments
  • kind: String sealed or singles.
unpricedQuantity Int!
Items with no market price (bulk, or not on Cardmarket), left out of value.
value Float!
Market value of everything with a price.

PullbookImport

An uploaded sales export. needs_mapping: its date, item and price columns weren't found by name, so call finishImport with a mapping (see headers and missingFields). running: it's being imported; read it again in a few seconds.

channel PullbookChannel!
createdAt ISO8601DateTime!
createdCount Int!
Sales recorded.
duplicateCount Int!
Orders already imported, skipped.
errorCount Int!
errors [ImportError!]!
filename String!
headers [String!]!
The file's column names.
id ID!
mapping [ImportMapping!]!
missingFields [String!]!
Required fields not mapped yet: sold_on, title, item_price.
overLimitCount Int!
Orders not imported because the plan's monthly sales were used up.
reviewCount Int!
Sold lines waiting to be matched (viewer.pullbook.reviewQueue).
rowsCount Int!
status String!
needs_mapping, running, done or failed (failed imports can be uploaded again: recorded orders are skipped).

PullbookItem

One line of a seller's inventory. cost is its share of the purchase's cost, split by market value; extraCost is what was spent on it alone (grading, say). Money is in the ledger's currency (Pullbook.currency).

card Card
condition String
cost Float!
costBasis Float!
cost + extraCost.
extraCost Float!
extraCostNote String
grade String
id ID!
kind PullbookItemKind!
label String!
opened Boolean!
An opened sealed item: no longer inventory; see its pulls.
openedFromId ID
The sealed item this came out of.
printing Printing
purchaseId ID!
quantity Int!
sealedProduct SealedProduct
sold Boolean!
valueOverride Float
Your value per unit for splitting cost, on the Cardmarket (€) scale; null uses the market price.

PullbookPurchase

Something a seller bought. Its totalCost (price + shipping + tax) is split across its items.

costUnknown Boolean!
You marked it "I don't know what I paid": its amounts are 0.
createdAt ISO8601DateTime!
id ID!
items [PullbookItem!]!
Everything that came with it, including pulls from opened sealed items.
kind PullbookPurchaseKind!
name String!
notes String
price Float!
purchasedOn ISO8601Date!
quantity Int!
sealedProduct SealedProduct
shipping Float!
source String
tax Float!
totalCost Float!
unpricedItems [PullbookItem!]!
Items with no market price, weighted as an average item.

PullbookReport

costUnknownNet Float!
Net from items with no known cost: in profit at a cost of 0.
group PullbookReportGroup!
inReview Int!
Sales left out because an item is waiting in review.
rows [PullbookReportRow!]!
total PullbookReportRow!
year Int

PullbookReportRow

One group's settled sales. Amounts are in your ledger's currency.

costBasis Float!
What the items that sold cost you.
costUnknown Boolean!
PURCHASE: it's marked cost unknown, so spent, costBasis and profit aren't real figures.
eventCost Float
EVENT and MONTH: what the streams and shows cost.
inStock Float
PURCHASE: the cost of what's left of it today.
key String
The purchase or event id, a product key (card:…, sealed:…, bulk) or the month (YYYY-MM-01); null for sales with nothing to group by.
label String!
net Float!
What the buyers paid, after fees and shipping.
profit Float!
net − costBasis − eventCost. Items with no known cost count at a cost of 0.
quantity Int!
sales Int!
spent Float
PURCHASE: what it cost in all, extra costs like grading included, whatever the year.

PullbookSale

One order. net = gross + shippingCharged − fees − shippingCost, in your ledger currency.

buyer String
channel PullbookChannel!
costBasis Float!
createdAt ISO8601DateTime!
event PullbookEvent
externalOrderId String
fees Float!
feesSource String!
schedule, manual or csv.
gross Float!
id ID!
lines [PullbookSaleLine!]!
needsReview Boolean!
net Float!
notes String
profit Float
null while a line is in review: its cost isn't known yet.
shippingCharged Float!
shippingCost Float!
soldOn ISO8601Date!

PullbookSaleLine

One thing sold. proceeds is its share of the sale's net (split by price); profit is proceeds − cost basis.

candidates [PullbookItem!]!
Your unsold copies of this card, oldest first (for REVIEW lines).
card Card
costBasis Float
id ID!
item PullbookItem
price Float!
proceeds Float!
profit Float
quantity Int!
saleId ID!
status PullbookSaleLineStatus!
title String!

PullbookTaxLot

One item sold: a summary of your records, not tax advice.

acquiredOn ISO8601Date
null when it wasn't from your ledger.
costBasis Float!
costUnknown Boolean!
From a purchase marked cost unknown: costBasis is 0 and gain is the whole proceeds, so don't report them as they are.
description String!
gain Float!
proceeds Float!
quantity Int!
soldOn ISO8601Date!
term String!
long (held more than a year), short, or unknown.

RedFlag

One sign that a card may be fake: what the photo shows against what the real card has.

confidence Float!
expected String!
kind String!
e.g. hp, attack_name, nonexistent_card, font, energy_symbol, spelling, colour, back.
seen String!
severity String!
strong or medium.
source String!
catalog (printed text vs our data), visual (photo vs the real card's scan), back, or measured.

SealedContent

One line of what's inside a sealed product.

accessoryKind String
sleeves, energy, damage_dice, coin, code_card, players_guide, …
card Card
lineType SealedLineType!
printing Printing
Set when the exact printing is known, e.g. a Pokémon Center-stamped promo.
product SealedProduct
For SEALED lines: the product inside.
quantity Int!
set Set
For PACK lines: which set's packs.
text String
The source wording for this line.

SealedProduct

A sealed product: booster pack, box, Elite Trainer Box, tin, collection, case…

cardmarketProductId Int
contents [SealedContent!]!
contentsStatus ContentsStatus!
expectedValue ExpectedValue!
What the contents are worth on average (packs at their set's per-pack EV, plus priced promos). Compare with price and msrp; note currencies.
Arguments
  • currency: Currency
id ID!
ID of the object.
image ExternalImage
Product photo, hosted by TCGplayer (linked, not copied).
kind String!
booster_pack, sleeved_pack, booster_box, half_box, booster_bundle, etb, pc_etb (Pokémon Center ETB), blister_1, blister_3, checklane_blister, mini_tin, tin, display, build_battle, prerelease_kit, collection, premium_collection, ultra_premium_collection, deck, promo_pack, art_bundle, case
msrp Float
msrpCurrency String
msrpSource String
Where the MSRP comes from. Standard ETBs have no official MSRP; we use a major retailer's list price.
name String!
price Price
Latest Cardmarket price, when we could match the product: euros unless you ask for another currency.
Arguments
  • currency: Currency
region Region!
releaseDate ISO8601Date
set Set
tcgplayerProductId Int
upc String

Series

A run of sets, e.g. Scarlet & Violet.

name String!
sets [Set!]!
slug String!

Set

An expansion or promo set.

cards CardConnection!
Cards in collector-number order.
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
code String!
Our set id: TCGdex's id, prefixed with asia: for Asian sets.
digital Boolean!
True for Pokémon TCG Pocket sets: app-only cards with no physical printing or market price.
expectedValue ExpectedValue!
Expected value of one booster pack at today's Cardmarket prices, in euros unless you ask for another currency.
Arguments
  • currency: Currency
externalIds [ExternalId!]!
id ID!
ID of the object.
legalities Legalities!
localizedNames [LocalizedName!]!
name String!
Arguments
  • locale: String Defaults to the set's primary language.
packLayout [PackSlot!]!
Cards per slot in one booster pack (standard SV/ME layout unless the set differs).
printedTotal Int
The number after the slash on cards.
ptcgoCode String
Code used by Pokémon TCG Online/Live, e.g. DAA.
pullRates [PullRate!]!
Per-pack odds by rarity, from published opening studies. Empty when none is on file.
region Region!
releaseDate ISO8601Date
sealedProducts [SealedProduct!]!
Sealed products of this set (boxes, ETBs, tins…).
series Series
symbol Image
tcgplayerGroupId Int
total Int
All cards including secret rares.

SlabVerification

Where to verify a graded slab's cert number with its grader, and whether the number is even possible for that grader. We don't look certs up ourselves: always check the grader's own page, since a fake slab can carry a real cert copied from another card.

cert String!
formatDescription String
formatValid Boolean
False when the number can't be one of this grader's certs (a red flag); null for an unknown grader.
grader String
PSA, CGC, BGS, SGC or TAG (null if unrecognised).
graderName String
note String
verifyUrl String
The grader's verification page.

Species

A Pokémon species (one National Pokédex number). Regional, Mega and Gigantamax variants are its forms.

cards CardConnection!
Cards featuring this species, newest sets first.
Arguments
  • after: String Returns the elements in the list that come after the specified cursor.
  • before: String Returns the elements in the list that come before the specified cursor.
  • first: Int Returns the first _n_ elements from the list.
  • last: Int Returns the last _n_ elements from the list.
  • includeCameos: Boolean Also include cards where it only appears in the artwork (mostly Trainers).
evolutionLine [Species!]!
Every species in the same evolution chain, by Pokédex number.
evolvesFrom Species
evolvesTo [Species!]!
forms [Form!]!
generation Int
genus String
e.g. Flame Pokémon.
id ID!
ID of the object.
isLegendary Boolean!
isMythical Boolean!
localizedNames [LocalizedName!]!
Name in every language we know.
name String!
Name in the requested locale, falling back to English.
Arguments
  • locale: String
nationalDex Int!
National Pokédex number.
slug String!
PokéAPI identifier, e.g. mr-mime.

Stat

name String!
hp, attack, defense, special-attack, special-defense, speed.
value Int!

TypeModifier

A weakness or resistance.

type String!
value String
e.g. ×2, -30.

UsageDay

day ISO8601Date!
requests Int!

Viewer

The account making this request, its plan limits and usage.

credential String
What authenticated this request: an API key's name, or the connected app's name.
dailyLimit Int!
Requests a day, shared by all the account's keys and connected apps.
email String!
perMinuteLimit Int!
plan String!
priceAlertLimit Int!
priceAlerts [PriceAlert!]!
pullbook Pullbook!
Your Pullbook seller ledger (created on first use).
usage [UsageDay!]!
Requests per day for the last 30 days, oldest first.
usageToday Int!
Requests counted today (UTC).
visionPerDay Int!
Photo checks (identifyCard, assessCondition) a day.
visionRemaining Int!
visionUsedToday Int!
webhookEndpointLimit Int!
webhookEndpoints [WebhookEndpoint!]!

Wear

Measured whitening along one edge or in one corner.

kind String!
edge or corner.
location String!
left, right, top, bottom, top_left, top_right, bottom_right, bottom_left.
severity String!
none, light, moderate, heavy or not_measurable.
whitening Float
Share of the band that is worn white; null where the border is itself white or silver.

WebhookDelivery

One POST to a webhook endpoint, retried up to 5 times with backoff.

asOf ISO8601Date
The price date that triggered it.
attempts Int!
createdAt ISO8601DateTime!
deliveredAt ISO8601DateTime
error String
event String!
id ID!
Also sent as the X-RarityDB-Delivery header.
payload JSON!
responseCode Int
status String!
pending (still retrying), succeeded or failed.

WebhookEndpoint

An https URL that receives signed event POSTs. The signing secret is only shown when it's created or rotated.

consecutiveFailures Int!
createdAt ISO8601DateTime!
deliveries [WebhookDelivery!]!
The 20 most recent, newest first.
failingSince ISO8601DateTime
Set after 5 failed deliveries in a row; cleared by the next success.
id ID!
url String!

WebhookEndpointWithSecret

secret String!
Verify X-RarityDB-Signature with this. Shown only now; rotate it if lost.
webhookEndpoint WebhookEndpoint!

Inputs

CardFilter

All given fields must match.

  • name: String — Case-insensitive substring of the card name.
  • setCode: String
  • region: Region
  • supertype: Supertype
  • nationalDex: Int — Cards featuring this Pokédex number.
  • type: String — Energy type, e.g. Fire.
  • rarity: String
  • illustrator: String
  • regulationMark: String
  • standardLegal: Boolean
  • digital: Boolean — false = physical cards only; true = TCG Pocket only.

ImportMappingInput

  • field: String! — One of order_id, sold_on, title, sku, set_name, number, quantity, item_price, shipping_charged, shipping_cost, fees, buyer, event.
  • headers: [String!]! — The column(s) holding it; several fee columns are added up.

PullInput

A card that came out of a purchase.

  • cardCode: String!
  • printingKey: String — Which printing, when the card has several (see Card.printings).
  • quantity: Int

SaleLineInput

One thing sold: an inventory item (itemId), a card (cardCode: your oldest unsold copy is used), or just a title (it waits in review).

  • itemId: ID
  • cardCode: String
  • title: String
  • quantity: Int
  • price: Float! — What the buyer paid for this line, before shipping.

Enums

AuthenticityVerdict

Never 'genuine': a photo can't prove a card is real.

  • LIKELY_FAKE — Strong evidence the card is counterfeit (see redFlags).
  • NO_RED_FLAGS — Everything we could check matches the real card. Not proof that it's real.
  • CANT_TELL — Not recognised, nothing to compare with, too little could be read, or a single medium red flag (not enough on its own).

CardOrder

  • RELEASE_DATE_DESC — Newest sets first, then card number.
  • RELEASE_DATE_ASC — Oldest sets first, then card number.
  • NAME — Alphabetical by card name.

ContentsStatus

  • VERIFIED — Checked by hand against the product listing.
  • PARSED — Read automatically from the retailer description; quantities are reliable, promo identity usually missing.
  • UNPARSED — We know the product but not its contents.

Currency

A currency to show prices in. Cardmarket prices are euros; others are converted at the European Central Bank's reference rate for the price's date.

  • USD
  • EUR
  • GBP
  • CAD
  • AUD
  • JPY

FormKind

  • DEFAULT
  • REGIONAL — Alolan, Galarian, Hisuian or Paldean form.
  • MEGA
  • GMAX — Gigantamax form.
  • OTHER

IdentificationStatus

  • MATCH — One card stands out. `printing` is set when the visible cues narrow it to one printing.
  • AMBIGUOUS — Several cards are plausible; see `candidates` and `hints`.
  • NO_MATCH — No card in the catalog fits what was read.

PriceAlertCondition

  • TREND_ABOVE — Fires the day the Cardmarket trend price rises to the threshold (EUR) or above.
  • TREND_BELOW — Fires the day the Cardmarket trend price falls to the threshold (EUR) or below.
  • CHANGE_ABOVE_PERCENT — Fires each day the trend price moves up or down by at least the threshold, in percent.

PriceProvider

Third-party price APIs you can query with your own key, sent as an X-Provider-Key-<Name> header (e.g. X-Provider-Key-Justtcg). We never store the key.

  • JUSTTCG — JustTCG: raw prices by condition and printing (USD).
  • POKEMONPRICETRACKER — PokemonPriceTracker: TCGplayer market price per printing plus graded eBay sales (USD).

PriceSource

  • CARDMARKET — Cardmarket (EU) daily price guide, in EUR.

PullbookChannel

  • WHATNOT — Whatnot: 8% of the item price + 2.9% of price and shipping + $0.30.
  • EBAY — eBay: 13.25% of price and shipping + $0.30 ($0.40 over $10).
  • TCGPLAYER — TCGplayer: 10.75% of the item price + 2.5% of price and shipping + $0.30.
  • IN_PERSON — A card show or local sale: no fees unless you enter them.
  • OTHER — Anywhere else: no fees unless you enter them.

PullbookEventKind

  • STREAM — A live stream (Whatnot, TikTok…).
  • SHOW — A card show.

PullbookItemKind

  • CARD — A card (a hit), possibly several copies.
  • BULK — A count of bulk cards.
  • SEALED — A sealed product; once opened its cost passes to its pulls.

PullbookPurchaseKind

  • SEALED — A sealed product from the catalog (pass sealedProductId).
  • LOT — A mixed lot or collection.
  • SINGLES — Singles bought as they are.
  • BREAK — A spot in someone else's break.

PullbookReportGroup

  • PURCHASE — Each purchase: what it cost, what sold from it, and what's left.
  • EVENT — Each stream or show, minus what it cost.
  • PRODUCT — Each card, sealed product or bulk.
  • MONTH — Each month, minus that month's stream and show costs.

PullbookSaleLineStatus

  • MATCHED — Sold from your inventory; its cost basis is frozen.
  • REVIEW — Waiting to be matched to an item (resolveSaleLine).
  • UNMATCHED — Not from your ledger; the cost basis was entered by hand.

Region

INTERNATIONAL sets are printed in English and European languages; ASIA sets are Japanese, Korean, Chinese, Indonesian and Thai releases with their own set lists.

  • INTERNATIONAL
  • ASIA

SealedLineType

  • PACK — Booster packs of one set.
  • CARD — A specific card, usually a promo. `card` is set when we know exactly which.
  • SEALED — Another sealed product, e.g. the bundles inside a case.
  • ACCESSORY — Sleeves, dice, coins, energy, code cards and the like.
  • VARIABLE — Contents that vary, e.g. assorted packs from several sets.

Supertype

The three kinds of card.

  • POKEMON
  • TRAINER
  • ENERGY

Unions

Entity

Anything search or resolveId can return. One of: Card, Set, Species, Printing, SealedProduct.