Help us shape the future of Go! Take the 2026 Go Developer Survey

tcgplayer

package module
v0.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 27, 2026 License: MIT Imports: 15 Imported by: 2

README

go-tcgplayer

A small, practical Go client for the TCGplayer API (catalog & pricing). It handles OAuth2 client-credentials, automatic token refresh, rate limiting, and resilient HTTP via retryablehttp.

This repo also includes a tiny CLI to dump category groups and products.

Features

  • Easy auth - fetches access_token using client-credentials and refreshes it before expiry.
  • Rate limiting - token-bucket guard around every request (defaults suitable for TCGplayer).
  • Resilient HTTP - built on hashicorp/go-retryablehttp.
  • Thread-safe - safe to use from multiple goroutines.
  • Tiny surface area - helpers for common catalog & pricing flows, plus a low-level Get for anything not wrapped yet.

Install

go get github.com/mtgban/go-tcgplayer

Quick start

package main

import (
    "context"
    "fmt"

    "github.com/mtgban/go-tcgplayer"
)

func main() {
    c, err := tcgplayer.NewClient("<PUBLIC_KEY>", "<PRIVATE_KEY>")
    if err != nil {
        // <handle err>
    }

    rows, err := c.GetMarketPricesByProducts(context.TODO(), []int{12345, 67890})
    if err != nil {
        // <handle err>
    }
    fmt.Println("retrieved rows:", len(rows))
}

Authentication

NewClient(publicKey, privateKey) wires a custom http.RoundTripper that:

  1. waits on a rate limiter,
  2. ensures a valid bearer token (refreshing if missing/near expiry),
  3. sets Authorization: Bearer <token> on each request.

Tokens are fetched from TCGplayer's /token endpoint using grant_type=client_credentials. Token acquisition is synchronized so bursts don't stampede the token endpoint.

Catalog helpers

  • Categories

    • GetCategoriesDetails(ctx context.Context, ids []int) ([]Category, error)
    • TotalCategories(ctx context.Context) (int, error)

  • Groups

    • ListAllCategoryGroups(ctx context.Context, category, offset int) ([]Group, error)
    • TotalGroups(ctx context.Context, category int) (int, error)

  • Products

    • GetProductsDetails(ctx context.Context, ids []int, includeSkus bool) ([]Product, error)
    • ListAllProducts(ctx context.Context, category int, productTypes []string, includeSkus bool, offset int) ([]Product, error)
    • ListProductSKUs(ctx context.Context, productId int) ([]SKU, error)

  • Category metadata (decodes the ids referenced by SKUs)

    • ListCategoryPrintings(ctx context.Context, category int) ([]Printing, error)
    • ListCategoryConditions(ctx context.Context, category int) ([]Condition, error)
    • ListCategoryLanguages(ctx context.Context, category int) ([]Language, error)
    • ListCategoryRarities(ctx context.Context, category int) ([]Rarity, error)
Product type filters
  • AllProductTypes - everything (Cards + sealed)
  • ProductTypesSingles - only Cards
  • ProductTypesSealed - sealed products (boxes, packs, etc.)

Pricing helpers

  • GetMarketPricesByProducts(ctx, productIds []int) ([]ProductPriceSet, error)
  • GetMarketPricesBySKUs(ctx, skuIds []int) ([]SKUPriceSet, error)

Each returns rows with the latest market pricing for the given IDs.

Pagination & limits

  • Offset + limit paging. Use MaxItemsInResponse (100) as the page size and iterate offsets: 0, 100, 200, ....
  • Batched IDs. Endpoints accept up to MaxIdsInRequest (250) IDs at a time. The client checks this and errors early if you exceed it.

Error handling

Low-level Get() returns a BaseResponse envelope. High-level helpers decode BaseResponse.Results into typed slices.

  • On malformed JSON, you get a Go error (with the raw body snippet).
  • On non-2xx responses, the call returns an error: composed from the envelope's API errors when present, otherwise from the HTTP status and raw body.

CLI

A simple CLI is included to dump category metadata and all products for a given category. It demonstrates offsets, batching, and concurrency.

# Build
go build ./cmd/tcgdumper

# Run
TCGPLAYER_PUBLIC_KEY=... TCGPLAYER_PRIVATE_KEY=... ./tcgdumper -category 3 -thread 8 > pokemon.json

Flags:

  • -category (int, required) - Category ID to dump
  • -thread (int, default 8) - worker concurrency for paging products
  • -pub / -pri (string) - TCGplayer public/private keys; fall back to the TCGPLAYER_PUBLIC_KEY / TCGPLAYER_PRIVATE_KEY environment variables
  • -p / -pretty - indent the JSON output (default is a single line)

License

MIT

Documentation

Overview

Package tcgplayer is a client for the TCGplayer catalog and pricing API, and defines the format of the catalog dumps cmd/tcgdumper writes.

Index

Constants

View Source 
const (
	// MaxItemsInResponse is the largest page a listing endpoint returns
	MaxItemsInResponse = 100
	// MaxIDsInRequest is the most ids a batched endpoint accepts
	MaxIDsInRequest = 250
)
View Source 
const (
	CategoryMagic = iota + 1
	CategoryYuGiOh
	CategoryPokemon
	CategoryAxisAllies
	CategoryBoardgames
	CategoryDDMiniatures
	CategoryEpic
	CategoryHeroclix
	CategoryMonsterpocalypse
	CategoryRedakai
	CategoryStarWarsMiniatures
	CategoryWorldOfWarcraftMiniatures
	CategoryWoW
	CategorySupplies
	CategoryOrganizersStores
	CategoryCardfightVanguard
	CategoryForceOfWill
	CategoryDiceMasters
	CategoryFutureCardBuddyFight
	CategoryWeissSchwarz

	CategoryTCGplayer
	CategoryDragonBallZ
	CategoryFinalFantasy
	CategoryUniVersus
	CategoryStarWarsDestiny
	CategoryDragonBallSuper
	CategoryDragoborne
	CategoryFunko
	CategoryMetaX
	CategoryCardSleeves
	CategoryDeckBoxes
	CategoryCardStorageTins
	CategoryLifeCounters
	CategoryPlaymats
	CategoryZombieWorldOrder
	CategoryTheCasterChronicles
	CategoryMyLittlePony
	CategoryWarhammerBooks
	CategoryWarhammerBigBoxGames
	CategoryWarhammerBoxSets
	CategoryWarhammerClampacks
	CategoryCitadelPaints
	CategoryCitadelTools
	CategoryWarhammerGameAccessories
	CategoryBooks
	CategoryExodus
	CategoryLightseekers
	CategoryProtectivePages
	CategoryStorageAlbums
	CategoryCollectibleStorage
	CategorySupplyBundles
	CategoryMunchkin
	CategoryWarhammerAgeOfSigmarChampions
	CategoryArchitect
	CategoryBulkLots
	CategoryTransformers
	CategoryBakugan
	CategoryKeyForge
	CategoryChronoClashSystem
	CategoryArgentSaga
	CategoryFleshAndBlood
	CategoryDigimon
	CategoryAlternateSouls
	CategoryGateRuler
	CategoryMetaZoo
	CategoryWIXOSS
	CategoryOnePiece
	CategoryMarvelComics
	CategoryDCComics
	CategoryLorcana
	CategoryBattleSpiritsSaga
	CategoryShadowverseEvolve
	CategoryGrandArchive
	CategoryAkora
	CategoryKryptik
	CategorySorceryContestedRealm
	CategoryAlphaClash
	CategoryStarWarsUnlimited
	CategoryDragonBallSuperFusionWorld
	CategoryUnionArena
	CategoryTCGplayerSupplies
	CategoryElestrals
	CategoryNeopetsBattledome
	CategoryPokemonJapan
	CategoryGundam
	CategoryHololive
	CategoryGodzilla
	CategoryRiftbound
	CategoryCookieRunBraverse
	CategoryPalworld
	CategoryCyberpunk
)

All active categories on the platform

Variables

View Source 
var (
	TokenURL = "https://api.tcgplayer.com/token"

	CatalogCategoriesURL = "https://api.tcgplayer.com/" + tcgAPIVersion + "/catalog/categories"
	CatalogProductsURL   = "https://api.tcgplayer.com/" + tcgAPIVersion + "/catalog/products"
	CatalogGroupsURL     = "https://api.tcgplayer.com/" + tcgAPIVersion + "/catalog/groups"

	PricingProductURL = "https://api.tcgplayer.com/" + tcgAPIVersion + "/pricing/product"
	PricingSKUURL     = "https://api.tcgplayer.com/" + tcgAPIVersion + "/pricing/sku"
)

Endpoint URLs, overridable for testing

View Source 
var AllProductTypes = []string{
	"3D Tokens",
	"3x Magic Booster Packs",
	"All 5 Intro Packs",
	"BakuCores",
	"Booster Battle Pack",
	"Booster Box",
	"Booster Pack",
	"Box Sets",
	"Bulk Lot",
	"Cards",
	"D & D Miniatures",
	"Dragoborne Sealed Products",
	"Dragon Ball Super Sealed Products",
	"Dragon Ball Super Singles",
	"Fat Pack",
	"Final Fantasy Sealed Products",
	"Final Fantasy Singles",
	"Funko Products",
	"Gift Card",
	"Heroclix",
	"Intro Pack",
	"Intro Pack Display",
	"Magic Booster Box Case",
	"Magic Deck Pack",
	"Osprey Publishing",
	"Precon/Event Decks",
	"Sealed Product",
	"Sealed Products",
	"Star Wars: Destiny Sealed Products",
	"Star Wars: Destiny Singles",
	"Supplies",
	"Tin",
	"Tokens",
	"UFS Sealed Products",
	"UFS Singles",
	"YGO Start Decks",
}

AllProductTypes lists every product type name the platform uses. No category files products under all of them; ProductTypes reports the ones a given category actually uses.

View Source 
var ProductTypesByCategory = map[int][]string{
	CategoryMagic:                         {"3x Magic Booster Packs", "All 5 Intro Packs", "Booster Battle Pack", "Booster Box", "Booster Pack", "Box Sets", "Cards", "Fat Pack", "Intro Pack", "Intro Pack Display", "Magic Booster Box Case", "Magic Deck Pack", "Precon/Event Decks", "Sealed Products"},
	CategoryYuGiOh:                        {"Booster Box", "Booster Pack", "Box Sets", "Cards", "Fat Pack", "Intro Pack", "Magic Booster Box Case", "Sealed Products", "Tin", "YGO Start Decks"},
	CategoryPokemon:                       {"Cards", "Sealed Products"},
	CategoryDDMiniatures:                  {"D & D Miniatures"},
	CategoryEpic:                          {"Cards"},
	CategoryHeroclix:                      {"Heroclix", "Sealed Products"},
	CategoryWoW:                           {"Booster Box", "Booster Pack", "Cards", "Sealed Products"},
	CategoryCardfightVanguard:             {"Cards", "Intro Pack", "Sealed Products"},
	CategoryForceOfWill:                   {"Cards", "Sealed Products"},
	CategoryDiceMasters:                   {"Cards", "Sealed Products"},
	CategoryFutureCardBuddyFight:          {"Cards", "Sealed Products"},
	CategoryWeissSchwarz:                  {"Cards", "Sealed Products"},
	CategoryTCGplayer:                     {"Gift Card"},
	CategoryDragonBallZ:                   {"Cards", "Sealed Products"},
	CategoryFinalFantasy:                  {"Final Fantasy Sealed Products", "Final Fantasy Singles"},
	CategoryUniVersus:                     {"UFS Sealed Products", "UFS Singles"},
	CategoryStarWarsDestiny:               {"Star Wars: Destiny Sealed Products", "Star Wars: Destiny Singles"},
	CategoryDragonBallSuper:               {"Dragon Ball Super Sealed Products", "Dragon Ball Super Singles"},
	CategoryDragoborne:                    {"Cards", "Dragoborne Sealed Products"},
	CategoryFunko:                         {"Funko Products"},
	CategoryMetaX:                         {"Cards", "Sealed Products"},
	CategoryCardSleeves:                   {"Supplies"},
	CategoryDeckBoxes:                     {"Supplies"},
	CategoryCardStorageTins:               {"Supplies"},
	CategoryLifeCounters:                  {"3D Tokens", "Sealed Products", "Supplies", "Tokens"},
	CategoryPlaymats:                      {"Supplies"},
	CategoryZombieWorldOrder:              {"Cards", "Sealed Products"},
	CategoryTheCasterChronicles:           {"Cards", "Sealed Products"},
	CategoryMyLittlePony:                  {"Sealed Products"},
	CategoryBooks:                         {"Osprey Publishing"},
	CategoryExodus:                        {"Cards", "Sealed Products"},
	CategoryLightseekers:                  {"Cards", "Sealed Products"},
	CategoryProtectivePages:               {"Supplies"},
	CategoryStorageAlbums:                 {"Supplies"},
	CategoryCollectibleStorage:            {"Supplies"},
	CategorySupplyBundles:                 {"Supplies"},
	CategoryMunchkin:                      {"Cards", "Sealed Products"},
	CategoryWarhammerAgeOfSigmarChampions: {"Cards", "Sealed Products"},
	CategoryBulkLots:                      {"Bulk Lot"},
	CategoryTransformers:                  {"Cards", "Sealed Products"},
	CategoryBakugan:                       {"BakuCores", "Cards", "Sealed Products"},
	CategoryKeyForge:                      {"Sealed Products"},
	CategoryChronoClashSystem:             {"Cards", "Sealed Products"},
	CategoryArgentSaga:                    {"Cards", "Sealed Products"},
	CategoryFleshAndBlood:                 {"Cards", "Sealed Products"},
	CategoryDigimon:                       {"Cards", "Sealed Products"},
	CategoryAlternateSouls:                {"Sealed Products"},
	CategoryGateRuler:                     {"Cards", "Sealed Products"},
	CategoryMetaZoo:                       {"Cards", "Sealed Products"},
	CategoryWIXOSS:                        {"Cards", "Sealed Products"},
	CategoryOnePiece:                      {"Cards", "Sealed Products"},
	CategoryLorcana:                       {"Cards", "Sealed Products"},
	CategoryBattleSpiritsSaga:             {"Cards", "Sealed Product"},
	CategoryShadowverseEvolve:             {"Cards", "Sealed Product"},
	CategoryGrandArchive:                  {"Cards", "Sealed Product"},
	CategoryAkora:                         {"Cards", "Sealed Product"},
	CategoryKryptik:                       {"Cards", "Sealed Product"},
	CategorySorceryContestedRealm:         {"Cards", "Sealed Products"},
	CategoryAlphaClash:                    {"Cards", "Sealed Products"},
	CategoryStarWarsUnlimited:             {"Cards", "Sealed Products"},
	CategoryDragonBallSuperFusionWorld:    {"Cards", "Sealed Products"},
	CategoryUnionArena:                    {"Cards", "Sealed Products"},
	CategoryTCGplayerSupplies:             {"Sealed Products"},
	CategoryElestrals:                     {"Cards", "Sealed Products"},
	CategoryPokemonJapan:                  {"Cards", "Sealed Products"},
	CategoryGundam:                        {"Cards", "Sealed Products"},
	CategoryHololive:                      {"Cards", "Sealed Products"},
	CategoryGodzilla:                      {"Cards", "Sealed Products"},
	CategoryRiftbound:                     {"Cards", "Sealed Products"},
	CategoryCookieRunBraverse:             {"Cards", "Sealed Products"},
}

ProductTypesByCategory holds the product types each category files its products under. Asking for only these keeps a dump from paging types the category never uses, and keeps it from missing the ones it does: the entries below were read off the platform and each accounts for its category's whole product count. Categories absent from the map are ones whose vocabulary is not known; ProductTypes falls back to every name for them, which a caller counting its results will find comes up short.

View Source 
var ProductTypesSealed = []string{
	"Booster Box",
	"Booster Pack",
	"Sealed Products",
	"Intro Pack",
	"Fat Pack",
	"Box Sets",
	"Precon/Event Decks",
	"Magic Deck Pack",
	"Magic Booster Box Case",
	"All 5 Intro Packs",
	"Intro Pack Display",
	"3x Magic Booster Packs",
	"Booster Battle Pack",
}

ProductTypesSealed lists the sealed product types Magic files products under. Prefer SealedProductTypes: a category files its own set, and one missing from this list is one whose products go unseen.

View Source 
var ProductTypesSingles = []string{"Cards"}

ProductTypesSingles lists the product type holding single cards for the categories that name it the common way. Prefer SinglesProductTypes, which answers for the categories naming it after themselves too.

Functions

func ProductTypes added in v0.1.2 

func ProductTypes(category int) []string

ProductTypes returns the product types the given category files its products under, or every known type when the category is not listed.

func SealedProductTypes added in v0.1.2 

func SealedProductTypes(category int) []string

SealedProductTypes returns the product types the given category files everything other than single cards under, sealed products above all.

func SinglesProductTypes added in v0.1.2 

func SinglesProductTypes(category int) []string

SinglesProductTypes returns the product types the given category files single cards under. It is empty for the categories that sell none, such as supplies and storage.

Types

type APIError added in v0.1.0 

type APIError struct {
	StatusCode int
	Messages   []string
}

APIError is a request the API answered with an error envelope, keeping the http status the message arrived under

func (*APIError) Error added in v0.1.0 

func (e *APIError) Error() string

Error joins the messages the API reported

type BaseResponse 

type BaseResponse struct {
	TotalItems int             `json:"totalItems"`
	Success    bool            `json:"success"`
	Errors     []string        `json:"errors"`
	Results    json.RawMessage `json:"results"`
}

BaseResponse is the envelope every endpoint wraps its payload in. Results is left raw for the caller to decode into the type the endpoint returns.

type CatalogDump added in v0.1.0 

type CatalogDump struct {
	Category   Category    `json:"category"`
	Conditions []Condition `json:"conditions"`
	Languages  []Language  `json:"languages"`
	Printings  []Printing  `json:"printings"`
	Rarities   []Rarity    `json:"rarities"`
	Groups     []Group     `json:"groups"`
	Products   []Product   `json:"products"`
}

CatalogDump is the envelope cmd/tcgdumper writes for a category. Naming it here keeps the program that writes a dump and the programs that read one on a single definition of the format, rather than each carrying its own.

func (*CatalogDump) PrintingNames added in v0.1.0 

func (d *CatalogDump) PrintingNames() map[int][]string

PrintingNames maps each product to the distinct printing names its skus carry, ordered as the dump lists the category's printings. A printing the dump does not list for a product is one that product is not sold in.

type Category 

type Category struct {
	CategoryID        int    `json:"categoryId"`
	Name              string `json:"name"`
	ModifiedOn        string `json:"modifiedOn"`
	DisplayName       string `json:"displayName"`
	SeoCategoryName   string `json:"seoCategoryName"`
	SealedLabel       string `json:"sealedLabel"`
	NonSealedLabel    string `json:"nonSealedLabel"`
	ConditionGuideURL string `json:"conditionGuideUrl"`
	IsScannable       bool   `json:"isScannable"`
	Popularity        int    `json:"popularity"`
}

Category is a game or product line the catalog is split into, such as Magic

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client talks to the TCGplayer API, holding the credentials every call needs. It acquires and refreshes bearer tokens on demand, holds requests to a rate limit, and retries the ones that fail transiently. A Client is safe for concurrent use.

func NewClient 

func NewClient(publicKey, privateKey string) (*Client, error)

NewClient returns a Client authenticating with the given key pair. Both keys are required. No request is made here: the first token is acquired by the first call that needs one.

func (*Client) Get 

func (tcg *Client) Get(ctx context.Context, link string) (*BaseResponse, error)

Get performs an authenticated GET request against link and parses the response envelope, leaving its payload for the caller to decode

func (*Client) GetCategoriesDetails 

func (tcg *Client) GetCategoriesDetails(ctx context.Context, categoryIDs []int) ([]Category, error)

GetCategoriesDetails returns the details of the given categories, at most MaxIDsInRequest of them per call

func (*Client) GetMarketPricesByProducts 

func (tcg *Client) GetMarketPricesByProducts(ctx context.Context, productIDs []int) ([]ProductPriceSet, error)

GetMarketPricesByProducts returns the current pricing of the given products, at most MaxIDsInRequest of them per call

func (*Client) GetMarketPricesBySKUs 

func (tcg *Client) GetMarketPricesBySKUs(ctx context.Context, skuIDs []int) ([]SKUPriceSet, error)

GetMarketPricesBySKUs returns the current pricing of the given skus, at most MaxIDsInRequest of them per call

func (*Client) GetProductsDetails 

func (tcg *Client) GetProductsDetails(ctx context.Context, productIDs []int, includeSkus bool) ([]Product, error)

GetProductsDetails returns the details of the given products, at most MaxIDsInRequest of them per call. Pass includeSkus to have each product carry the skus it is sold as.

func (*Client) ListAllCategoryGroups 

func (tcg *Client) ListAllCategoryGroups(ctx context.Context, category, offset int) ([]Group, error)

ListAllCategoryGroups returns one page of a category's groups, starting at offset and holding at most MaxItemsInResponse of them. Pair it with TotalGroups to walk a whole category.

func (*Client) ListAllProducts 

func (tcg *Client) ListAllProducts(ctx context.Context, category int, productTypes []string, includeSkus bool, offset int) ([]Product, error)

ListAllProducts returns one page of a category's products, starting at offset and holding at most MaxItemsInResponse of them. Pair it with TotalProducts to walk a whole category.

func (*Client) ListCategoryConditions added in v0.0.3 

func (tcg *Client) ListCategoryConditions(ctx context.Context, category int) ([]Condition, error)

ListCategoryConditions returns the conditions a category's skus reference

func (*Client) ListCategoryLanguages added in v0.0.3 

func (tcg *Client) ListCategoryLanguages(ctx context.Context, category int) ([]Language, error)

ListCategoryLanguages returns the languages a category's skus reference

func (*Client) ListCategoryPrintings 

func (tcg *Client) ListCategoryPrintings(ctx context.Context, category int) ([]Printing, error)

ListCategoryPrintings returns the printings a category's skus reference

func (*Client) ListCategoryRarities added in v0.0.3 

func (tcg *Client) ListCategoryRarities(ctx context.Context, category int) ([]Rarity, error)

ListCategoryRarities returns the rarities a category's products carry

func (*Client) ListProductSKUs 

func (tcg *Client) ListProductSKUs(ctx context.Context, productID int) ([]SKU, error)

ListProductSKUs returns the skus a product is sold as

func (*Client) TotalCategories 

func (tcg *Client) TotalCategories(ctx context.Context) (int, error)

TotalCategories reports how many categories the platform holds

func (*Client) TotalGroups 

func (tcg *Client) TotalGroups(ctx context.Context, category int) (int, error)

TotalGroups reports how many groups a category holds

func (*Client) TotalProducts 

func (tcg *Client) TotalProducts(ctx context.Context, category int, productTypes []string) (int, error)

TotalProducts reports how many products a category holds, optionally narrowed to the given product types

type Condition added in v0.0.3 

type Condition struct {
	ConditionID  int    `json:"conditionId"`
	Name         string `json:"name"`
	Abbreviation string `json:"abbreviation"`
	DisplayOrder int    `json:"displayOrder"`
}

Condition is a grade a category's products are sold in, such as Near Mint

type Group 

type Group struct {
	GroupID      int    `json:"groupId"`
	Name         string `json:"name"`
	Abbreviation string `json:"abbreviation"`
	Supplemental bool   `json:"supplemental"`
	PublishedOn  string `json:"publishedOn"`
	ModifiedOn   string `json:"modifiedOn"`
	CategoryID   int    `json:"categoryId"`
}

Group is a set, expansion or other collection a category files its products under

func (Group) ReleaseDate added in v0.1.0 

func (g Group) ReleaseDate() string

ReleaseDate is the group's publish date without the time of day. ReleaseDate is the day the group was published, without the time of day

type Language added in v0.0.3 

type Language struct {
	LanguageID   int    `json:"languageId"`
	Name         string `json:"name"`
	Abbreviation string `json:"abbr"`
}

Language is a language a category's products are printed in

type Printing 

type Printing struct {
	PrintingID   int    `json:"printingId"`
	Name         string `json:"name"`
	DisplayOrder int    `json:"displayOrder"`
	ModifiedOn   string `json:"modifiedOn"`
}

Printing is a finish a category's cards are printed in, such as Foil

type Product 

type Product struct {
	ProductID  int    `json:"productId"`
	Name       string `json:"name"`
	CleanName  string `json:"cleanName"`
	ImageURL   string `json:"imageUrl"`
	GroupID    int    `json:"groupId"`
	URL        string `json:"url"`
	ModifiedOn string `json:"modifiedOn"`

	// Never returned by the API, which does not report the product type a
	// product is filed under; tcgdumper stamps the type it fetched the
	// product by, so it is present in catalog dumps only
	ProductType string `json:"productType,omitempty"`

	// Only available for catalog API calls
	Skus []SKU `json:"skus,omitempty"`
	// Only available for catalog API calls
	ExtendedData []struct {
		Name        string `json:"name"`
		DisplayName string `json:"displayName"`
		Value       string `json:"value"`
	} `json:"extendedData,omitempty"`
}

Product is a single item in the catalog, a card or a sealed product

func (Product) Extended added in v0.1.0 

func (p Product) Extended(name string) string

Extended reads the extendedData entry a product carries under name, or "" when it carries none. The catalog files a card's collector number, rarity and the rest there rather than as fields of their own.

type ProductPriceSet 

type ProductPriceSet struct {
	ProductID      int     `json:"productId"`
	LowPrice       float64 `json:"lowPrice"`
	MarketPrice    float64 `json:"marketPrice"`
	MidPrice       float64 `json:"midPrice"`
	DirectLowPrice float64 `json:"directLowPrice"`
	SubTypeName    string  `json:"subTypeName"`
}

ProductPriceSet is the current pricing of one product, for one sub type

type Rarity added in v0.0.3 

type Rarity struct {
	RarityID    int    `json:"rarityId"`
	DisplayText string `json:"displayText"`
	DBValue     string `json:"dbValue"`
}

Rarity is a rarity a category's cards are printed at

type SKU 

type SKU struct {
	SKUID       int `json:"skuId"`
	ProductID   int `json:"productId"`
	LanguageID  int `json:"languageId"`
	PrintingID  int `json:"printingId"`
	ConditionID int `json:"conditionId"`
}

SKU is a sellable variant of a product: one combination of language, printing and condition

type SKUPriceSet 

type SKUPriceSet struct {
	SKUID              int     `json:"skuId"`
	LowPrice           float64 `json:"lowPrice"`
	LowestShipping     float64 `json:"lowestShipping"`
	LowestListingPrice float64 `json:"lowestListingPrice"`
	MarketPrice        float64 `json:"marketPrice"`
	DirectLowPrice     float64 `json:"directLowPrice"`
}

SKUPriceSet is the current pricing of one sku

Source Files

View all Source files

Directories

Path Synopsis
cmd
tcgdumper command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.