Hobbiesville APIbuylist.hobbiesville.com ↗
Query the Hobbiesville trading card buylist for Pokémon, MTG, and One Piece. Get per-condition cash and store-credit buy prices in CAD via 4 structured endpoints.
What is the Hobbiesville API?
The Hobbiesville Buylist API exposes 4 endpoints that cover the full buylist catalogue at buylist.hobbiesville.com, returning per-condition cash and store-credit buy prices in CAD for trading cards across Pokémon, Pokémon Japanese, Magic: the Gathering, and One Piece. The core search_buylist endpoint accepts filters for card name, set code, rarity, finish, hotlist status, and release date, and returns up to 24 items per page with a conditions array detailing every grade the store currently buys.
curl -X GET 'https://api.parse.bot/scraper/e551975a-189d-493f-8963-5d84c340f908/search_buylist?sort=relevance&query=pikachu&set_name=ME%3A+30th+Celebration+Classic+Collection' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace buylist-hobbiesville-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Hobbiesville Buylist — discover sets, browse finishes, search cards."""
from parse_apis.buylist_hobbiesville_com_api import Hobbiesville, SortOrder, InputFormatInvalid
client = Hobbiesville()
# List available finishes and rarities for the default product line.
print("Finishes:", [f for f in client.cards.list_finishes(limit=10)])
print("Rarities:", [r for r in client.cards.list_rarities(limit=10)])
# Pick the first set to use as a search filter.
card_set = client.card_sets.list(limit=1).first()
if card_set is not None:
print(f"\nSet: {card_set.name} (code={card_set.code})")
# Search cards in that set, sorted by descending buy price.
for card in client.cards.search(
set_name=card_set.code,
sort=SortOrder.BUY_PRICE_DESC,
limit=5,
):
print(f" {card.name} cash=${card.best_buy_price_cash} credit=${card.best_buy_price_credit}")
# Per-condition pricing breakdown.
for cond in card.conditions:
print(f" {cond.condition}: buy_cash=${cond.buy_price_cash} sell=${cond.sell_price} qty={cond.stock_quantity}")
# Standalone keyword search across all sets.
try:
hit = client.cards.search(query="pikachu", limit=1).first()
except InputFormatInvalid as e:
print(f"Bad input: {e.message}")
hit = None
if hit is not None:
print(f"\nFound: {hit.name} [{hit.set_name.name}] rarity={hit.rarity} hot={hit.is_hot}")
print("exercised: card_sets.list / cards.search / cards.list_finishes / cards.list_rarities")
Searches the buylist catalogue and returns one row per card product (a specific printing + finish), each with a conditions array holding every raw condition the store buys (NM/LP/MP for English Pokémon; full names such as Near Mint / Lightly Played for Pokemon Japanese) with its cash buy price, store-credit buy price, the store's retail sell price, and the store's own stock quantity. Prices are in CAD; a buy price of 0 means the store is not currently buying that condition. Results are paged 24 per page: page defaults to 1, total_results/total_pages come from the site, and has_more tells whether a further page exists. Omitting query lists the whole product line. set_name must match a code returned by list_sets; rarity is a free-text rarity label as shown on the site (e.g. one shape: Secret Rare); finish is a finish label as returned by list_finishes; an unknown set, rarity or finish simply yields an empty result. Each call costs two upstream requests (results + count).
| Param | Type | Description |
|---|---|---|
| page | integer | 1-based result page, 24 items per page. |
| sort | string | Result ordering. |
| query | string | Card name text to search for. Omitted = no name filter. |
| finish | string | Card finish label exactly as returned by list_finishes.finishes[*] (e.g. one shape: Holofoil); matches search_buylist.items[*].finish. Omitted = all finishes. |
| rarity | string | Rarity label exactly as the site spells it. Omitted = all rarities. |
| hotlist | boolean | true restricts results to cards on the store's hotlist (is_hot). |
| set_name | string | Exact set code from list_sets.sets[*].code. Omitted = all sets. |
| product_line | string | Game catalogue to search; verified values are Pokemon and Pokemon Japanese. Other product lines listed on the site are untested. |
| max_release_date | string | ISO date YYYY-MM-DD; only cards from sets released on or before this date. |
| min_release_date | string | ISO date YYYY-MM-DD; only cards from sets released on or after this date. |
{
"type": "object",
"fields": {
"page": "page returned",
"items": "array of card products; each has id, name, set_name, rarity (null when the site has none), finish, product_type, product_line, is_hot, best_buy_price_cash, best_buy_price_credit (best condition's buy prices, CAD), image_url, and conditions (array of {variant_id, condition, sku, buy_price_cash, buy_price_credit, sell_price, stock_quantity})",
"currency": "price currency code reported by the site (CAD)",
"has_more": "true when a later page exists",
"page_size": "items per page (24)",
"total_pages": "site-reported page count",
"total_results": "site-reported total matching products"
},
"sample": {
"data": {
"page": 1,
"items": [
{
"id": "xHUrj7vlqO",
"name": "Pikachu (040/128) - Holofoil - Pikachu Rare",
"finish": "Holofoil",
"is_hot": false,
"rarity": "Pikachu Rare",
"set_name": "ME: 30th Celebration",
"image_url": "https://cdn.shopify.com/s/files/1/0261/9795/0486/files/712944.jpg?v=1789683651",
"conditions": [
{
"sku": "PKM-M3C-040-HF-PR-712944-1",
"condition": "NM",
"sell_price": 3.25,
"variant_id": "50225117167754",
"buy_price_cash": 1.63,
"stock_quantity": 0,
"buy_price_credit": 2.04
},
{
"sku": "PKM-M3C-040-HF-PR-712944-2",
"condition": "LP",
"sell_price": 2.76,
"variant_id": "50225117200522",
"buy_price_cash": 1.38,
"stock_quantity": 2,
"buy_price_credit": 1.72
},
{
"sku": "PKM-M3C-040-HF-PR-712944-3",
"condition": "MP",
"sell_price": 2.11,
"variant_id": "50225117233290",
"buy_price_cash": 1.06,
"stock_quantity": 0,
"buy_price_credit": 1.33
}
],
"product_line": "Pokemon",
"product_type": "Single",
"best_buy_price_cash": 1.63,
"best_buy_price_credit": 2.04
}
],
"currency": "CAD",
"has_more": true,
"page_size": 24,
"total_pages": 13,
"total_results": 289
},
"status": "success"
}
}About the Hobbiesville API
What the API Returns
The search_buylist endpoint is the primary data source. Each result item includes fields such as id, name, set_name, rarity, finish, product_type, product_line, and is_hot (hotlist flag), alongside a conditions array. Each entry in that array carries the condition label (e.g. NM, LP, MP for English Pokémon; full names like Near Mint or Lightly Played for Pokémon Japanese) together with its cash and store-credit buy price in CAD. The response also includes pagination metadata: page, page_size (fixed at 24), total_pages, total_results, and has_more.
Filter Reference Endpoints
Three lookup endpoints feed valid filter values into search_buylist. list_sets returns an array of {name, code} objects for a given product_line—the code field is exactly what search_buylist accepts as set_name. For Pokémon, this typically yields around 200 sets ordered newest first. list_rarities returns the ordered rarity labels (e.g. Secret Rare) that the rarity parameter accepts, roughly 30 for Pokémon. list_finishes returns the finish labels (e.g. Holofoil) that appear in search_buylist items' finish field. All three endpoints accept an optional product_line parameter.
Pagination and Filtering
search_buylist supports a 1-based page parameter; each page holds 24 items. You can combine filters: pass hotlist=true to restrict results to cards the store is actively prioritizing, use max_release_date (ISO YYYY-MM-DD) to cap results by set release date, and supply sort to control result ordering. Omitting any optional parameter broadens the filter—leaving query empty returns all cards, and leaving set_name empty spans all sets.
Product Line Coverage
Verified product_line values are Pokemon, Pokemon Japanese, Magic: the Gathering, and One Piece. The list_rarities and list_finishes endpoints confirm support for all four. search_buylist and list_sets document verified support for Pokemon and Pokemon Japanese; other product lines listed on the site are likely usable with the same parameter but should be confirmed by calling the filter endpoints first.
The Hobbiesville API is a managed, monitored endpoint for buylist.hobbiesville.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when buylist.hobbiesville.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official buylist.hobbiesville.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Compare Hobbiesville's cash vs. store-credit buy prices across card conditions before selling a collection
- Monitor the hotlist (
is_hotflag) to track which cards the store is actively prioritizing - Filter by
max_release_dateto find buy prices for cards from a specific era of Pokémon sets - Build a sell-optimization tool that maps owned cards to current CAD buylist prices per condition
- Enumerate all available sets via
list_setsto populate a set selector in a card-management app - Track rarity-level pricing trends by iterating
list_raritiesresults againstsearch_buylist - Cross-reference finish types from
list_finisheswith buy prices to identify premium buyback rates for holofoil variants
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Hobbiesville offer an official developer API for its buylist?+
What does the `conditions` array in a `search_buylist` result actually contain?+
conditions array represents one grade the store buys for that card printing. It includes the condition label (e.g. NM, LP, MP for English Pokémon, or Near Mint, Lightly Played for Pokémon Japanese) along with the corresponding cash buy price and store-credit buy price, both in CAD.How do I know which `set_name` values are valid for the `search_buylist` filter?+
list_sets with the relevant product_line first. It returns an array of {name, code} objects; the code value is exactly what search_buylist accepts as set_name. For Pokémon, this list typically contains around 200 sets ordered newest first.Does the API return historical buylist prices or price change history?+
Does the API cover all product lines shown on the Hobbiesville buylist site, such as One Piece and Magic: the Gathering?+
list_rarities and list_finishes confirm support for Pokemon, Pokemon Japanese, Magic: the Gathering, and One Piece. search_buylist and list_sets document verified behavior for the Pokémon lines; coverage for MTG and One Piece should be validated by testing those product_line values directly. If a product line returns no results, you can fork this API on Parse and revise it to extend verified support.