Grand Archive APIgrandarchive.com ↗
Access Grand Archive TCG card data, news articles, Ban & Restricted announcements, and champion listings via 6 structured API endpoints.
What is the Grand Archive API?
The Grand Archive API provides 6 endpoints covering the full Grand Archive TCG card database and news feed. Use search_cards to query card metadata — including name, element, class, types, effect text, editions, and circulation data — or use get_articles_list to pull paginated news, guides, and announcements from the official Grand Archive content feed sorted by publication date.
curl -X GET 'https://api.parse.bot/scraper/ae026817-0799-4e47-893b-1d42bf2f037f/get_articles_list?page=1&category=news&page_size=3' \ -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 grandarchive-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: Grand Archive TCG SDK — browse news, search cards, check bans."""
from parse_apis.grand_archive_tcg_api import GrandArchive, CardType, CardClass, Element, Category, ArticleNotFound
client = GrandArchive()
# List recent articles filtered by "news" category, capped at 3.
for article in client.articles.list(category=Category.NEWS, limit=3):
print(article.title, article.published_at)
# Drill into one article's full body content.
article = client.articles.list(limit=1).first()
if article:
detail = client.articles.get(slug=article.slug)
print(detail.title, detail.body[:80] if detail.body else "")
# Search cards by name and element, take one to inspect.
card = client.cards.search(query="Lorraine", element=Element.NORM, limit=1).first()
if card:
print(card.name, card.level, card.life, card.element)
for edition in card.editions[:2]:
print(edition.slug, edition.collector_number, edition.rarity)
# Browse all champions with a class filter.
for champ in client.cards.champions(limit=3):
print(champ.name, champ.classes, champ.life)
# Typed error handling: fetch a non-existent article.
try:
client.articles.get(slug="this-article-does-not-exist-xyz")
except ArticleNotFound as exc:
print(f"Not found: {exc.slug}")
print("exercised: articles.list / articles.get / cards.search / cards.champions / ArticleNotFound")
Fetch a paginated list of articles from the Grand Archive TCG news feed. Returns articles sorted by publication date descending. Supports filtering by category. Each article includes title, intro, slug, URL, publication timestamp, categories, and hero image. Use page and page_size to paginate through the full archive.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number to fetch. |
| category | string | Category to filter by. Known values include: news, guide, hidden. Omitting returns all categories. |
| page_size | integer | Number of articles per page. |
{
"type": "object",
"fields": {
"page": "integer, current page number",
"total": "integer, total number of articles",
"articles": "array of article summary objects with title, intro, slug, url, published_at, categories, hero_image",
"page_size": "integer, items per page",
"page_count": "integer, total number of pages"
},
"sample": {
"data": {
"page": 1,
"total": 25,
"articles": [
{
"url": "https://www.gatcg.com/article/rules-update-copied-activations",
"slug": "rules-update-copied-activations",
"intro": "A rules update on copying card activations.",
"title": "Rules Update: Copied Activations",
"categories": [
"news"
],
"hero_image": "https://ga-mainsite-common.s3.us-west-2.amazonaws.com/media/Rules_Update_529c5b5f74.jpg",
"published_at": "2026-04-20T22:27:03.380Z"
}
],
"page_size": 3,
"page_count": 9
},
"status": "success"
}
}About the Grand Archive API
Card Database Endpoints
The search_cards endpoint accepts filters for query (card name), type, class, and element, returning paginated results with up to 50 cards per page. Each card object includes name, classes, element, types, effect, level, life, cost, slug, and an editions array carrying set and circulation data. The has_more boolean and total_pages field make cursor-style pagination straightforward. For champion cards specifically, get_champions pre-filters by type CHAMPION and returns the same card object shape without requiring you to pass a type filter manually.
News and Article Endpoints
get_articles_list returns paginated article summaries with title, intro, slug, url, published_at, categories, and hero_image. The optional category parameter accepts values like news, guide, or hidden to narrow results. For full article content, pass any slug to get_article_detail, which returns the complete HTML body alongside all summary fields. If the slug doesn't match a published article, the response returns a stale_input error with kind input_not_found.
Ban & Restricted and Latest Content
get_ban_and_restricted_articles returns all articles with 'Ban' in the title, including their full body HTML — useful for tracking card legality changes across Standard and Pantheon formats without filtering manually. get_latest_articles accepts a limit parameter (1–50) and returns the most recently published articles, making it suitable for polling or populating a recent-news widget.
The Grand Archive API is a managed, monitored endpoint for grandarchive.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when grandarchive.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 grandarchive.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?+
- Build a card search tool filtered by element, class, or type using
search_cardsresponse fields - Track Ban & Restricted list changes for Standard and Pantheon formats via
get_ban_and_restricted_articles - Populate a champion gallery by pulling all Champion cards with
get_champions - Display edition and circulation data per card using the
editionsarray from card objects - Monitor new Grand Archive announcements by polling
get_latest_articleswith a limit parameter - Render full article pages including hero images and HTML body via
get_article_detail - Categorize TCG content by filtering
get_articles_listwith theguideornewscategory parameter
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Grand Archive have an official developer API?+
What does the `editions` field on a card object contain?+
editions array contains one entry per print run or set release for that card, including set information and circulation data. It allows you to distinguish between different printings of the same card name.Does the API expose deck lists, tournament results, or player rankings?+
search_cards and get_champions) and editorial content (via the article endpoints). You can fork it on Parse and revise it to add an endpoint for tournament or player data if that becomes available from the source.Is there a limit to how many cards `search_cards` can return per request?+
page_size parameter is capped at 50 items per page. Use the total_pages and has_more response fields to iterate through the full result set across multiple requests.Does `get_article_detail` return articles from all categories including 'hidden'?+
slug you supply, regardless of category. The hidden category is a valid filter in get_articles_list and those slugs can be passed to get_article_detail the same way as news or guide articles. There is no separate category-gating on the detail endpoint.