onepiece APIonepiece.gg ↗
Access One Piece TCG deck lists, card details, and archetype statistics from onepiece.gg via 2 structured API endpoints.
What is the onepiece API?
The onepiece.gg API provides access to One Piece Trading Card Game deck data across 2 endpoints, returning card lists, archetype win/placing statistics, deck pricing, and format metadata. The get_decks endpoint lets you paginate and search the full deck catalog filtered by game format, while get_deck_detail returns a complete breakdown of any individual deck including its card quantities, author, view count, and tournament context.
curl -X GET 'https://api.parse.bot/scraper/c9ab612d-c41d-458f-ba72-b63c9c1ba898/get_decks?page=1&limit=5&format=OP13&search=Luffy' \ -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 onepiece-gg-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: OnePiece.gg Deck API — browse decks, drill into details."""
from parse_apis.onepiece_gg_deck_api import OnePiece, DeckNotFound
client = OnePiece()
# Browse recent decks, capped at 5 total items.
for deck in client.decks.search(limit=5):
print(deck.deck_name, deck.views, deck.colors)
# Drill into the first deck from a format-filtered search.
summary = client.decks.search(format="OP13", limit=1).first()
if summary:
detail = summary.details()
print(detail.deck_name, detail.description, detail.is_tournament)
for card in detail.cards[:3]:
print(card.card_id, card.card_name, card.quantity)
# Point-lookup by slug with typed error handling.
try:
deck = client.decks.get(slug="nonexistent-slug-xyz")
print(deck.deck_name, deck.archetype.name)
except DeckNotFound as exc:
print(f"Deck not found: {exc.slug}")
print("exercised: decks.search / DeckSummary.details / decks.get / DeckNotFound")
Get a paginated list of decks with resolved card names and statistics. Results are sorted by date descending. Each deck includes its full card list with resolved names, color composition, archetype info, and metadata. Paginates via integer page number; total may be null.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination. |
| limit | integer | Number of decks per page. |
| format | string | Filter by game format (e.g. OP13, OP12, EB-03). |
| search | string | Search keyword to filter decks by name or content. |
{
"type": "object",
"fields": {
"page": "current page number",
"decks": "array of deck objects with card lists, colors, archetype info, and metadata",
"limit": "number of decks requested per page",
"total": "total number of matching decks (may be null)",
"has_more": "boolean indicating if more pages are available"
},
"sample": {
"data": {
"page": 1,
"decks": [
{
"date": "1781157432",
"slug": "monkeydluffy-deck-2wcsz",
"cards": [
{
"card_id": "EB02-052",
"quantity": 2,
"card_name": "Enel"
}
],
"price": 317.69,
"views": 0,
"author": null,
"colors": [
"yellow"
],
"format": "OP12",
"archetype": {
"name": null,
"wins": null,
"points": null,
"placings": null
},
"deck_name": "Monkey.D.Luffy Deck",
"is_tournament": false
}
],
"limit": 5,
"total": null,
"has_more": true
},
"status": "success"
}
}About the onepiece API
Deck Catalog via get_decks
The get_decks endpoint returns a paginated list of decks sorted by date descending. Each deck object in the decks array includes card lists with resolved names, color and archetype information, and metadata fields like format and slug. You can filter results using the format parameter (e.g. OP13, OP12) to scope results to a specific card set release, or use the search parameter to find decks by name or content. Pagination is controlled by page and limit, and the response includes a has_more boolean so you can walk through all results programmatically. Note that total may be null depending on the query.
Individual Deck Detail via get_deck_detail
Passing a deck's slug (obtained from get_decks results) to get_deck_detail returns the full card list with card_id, card_name, and quantity for every card in the deck. Additional fields include deck_name, description (which may contain tournament placement notes), format, author, views, date, and an estimated price in USD. The archetype object exposes aggregate competitive data: name, wins, points, and placings, though any of these may be null for non-competitive or community decks.
Coverage and Format Filtering
Decks span multiple One Piece TCG formats identifiable by set codes like OP12 or OP13. Filtering by format in get_decks is the primary way to isolate results from a specific meta period. Because total can be null, clients should rely on has_more to detect end-of-results rather than calculating page count from total records.
The onepiece API is a managed, monitored endpoint for onepiece.gg — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when onepiece.gg 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 onepiece.gg 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?+
- Track which archetypes are placing in tournaments by reading
archetype.winsandarchetype.placingsfields - Compare card choices across decks in the same format using
get_deckswith theformatfilter and card list data - Monitor deck price trends by collecting
pricefields fromget_deck_detailover time - Build a deck search tool using the
searchparameter to surface decks by card name or strategy keyword - Identify the most-viewed competitive builds by sorting on
viewsfromget_deck_detailresponses - Aggregate card frequency across a format by iterating paginated
get_decksresults and counting card quantities
| 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 onepiece.gg have an official developer API?+
What does the archetype object in get_deck_detail actually contain?+
archetype object has four fields: name (the archetype label), wins, points, and placings. These reflect aggregate competitive performance associated with the deck's archetype. All four values may be null for casual or community-submitted decks that lack tournament data.Can I filter decks by color, card ID, or leader card?+
get_decks endpoint supports filtering by format and search keyword only. Color, specific card ID, and leader card filtering are not current parameters. You can fork this API on Parse and revise it to add those filter options.How should I handle pagination when total is null?+
total field in get_decks responses may be null, so you cannot always calculate the total page count upfront. Use the has_more boolean to determine whether additional pages exist and increment page until has_more returns false.Does the API return individual card rulings or card text?+
cards array in get_deck_detail returns card_id, card_name, and quantity per card — deck composition data only. You can fork this API on Parse and revise it to add an endpoint that retrieves full card text and rulings if onepiece.gg exposes that data.