Spuckwaffel APIdumpspace.spuckwaffel.com ↗
Access Unreal Engine game SDK dumps via 20 endpoints. Retrieve classes, structs, enums, functions, memory offsets, and inheritance chains by game hash.
What is the Spuckwaffel API?
The Dumpspace API provides structured access to SDK dump data for Unreal Engine games across 20 endpoints, covering classes, structs, enums, functions, and global memory offsets. Use get_class_overview to retrieve member tables with names, types, and byte offsets for any class in a dump, or get_functions_for_class to pull full function signatures including return types, parameters, and flags. All data is keyed by a per-game hash retrieved from list_games or search_games.
curl -X GET 'https://api.parse.bot/scraper/029aa06e-61ee-455b-9020-4e1a4e3bc678/list_games?engine=Unreal-Engine-4' \ -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 dumpspace-spuckwaffel-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.
"""Dumpspace SDK — explore Unreal Engine game SDK dumps."""
from parse_apis.dumpspace_api import Dumpspace, Engine, SearchType, GameNotFound
client = Dumpspace()
# List UE4 games and pick the first one
game = client.games.list(engine=Engine.UNREAL_ENGINE_4, limit=3).first()
print(f"Game: {game.name} ({game.hash}), engine: {game.engine}")
# Explore classes in the game dump via sub-resource navigation
for cls_name in game.classes.list(limit=5):
print(f" Class: {cls_name}")
# Get detailed class info navigating from the game
class_info = game.classes.overview(class_name="AAIController")
print(f"\n{class_info.name}: size={class_info.size} bytes, parents={class_info.inheritance}")
for member in class_info.members[:3]:
print(f" {member.name}: {member.type} @ {member.offset}")
# Get MDK C++ code for the class
mdk = game.classes.mdk_code(class_name="AAIController")
print(f"\nMDK code preview: {mdk.code[:80]}...")
# Search within the game dump for types containing "Vector"
for result in game.global_search(query="Vector", search_type=SearchType.TYPE, limit=3):
print(f" Found: {result.type} — {result.name} (parent: {result.parent})")
# Typed error handling for a bad game hash
try:
client.games.get(hash="nonexistent_hash_value")
except GameNotFound as exc:
print(f"\nExpected error: {exc}")
print("\nExercised: games.list, classes.list, classes.overview, classes.mdk_code, global_search, games.get")
Returns all games available on Dumpspace. Each game includes its hash identifier, name, engine type, and uploader info. Optionally filter by engine type to narrow results. The game hash from this endpoint is required as input for all game-specific endpoints (classes, structs, enums, functions, offsets).
| Param | Type | Description |
|---|---|---|
| engine | string | Filter by engine type. Accepted values: 'Unreal-Engine-4', 'Unreal-Engine-5'. |
{
"type": "object",
"fields": {
"games": "array of game objects each with hash, name, engine, location, uploaded, and uploader"
},
"sample": {
"data": {
"games": [
{
"hash": "6b77eceb",
"name": "Fortnite",
"engine": "Unreal-Engine-5",
"location": "Fortnite",
"uploaded": 1764791066718,
"uploader": {
"link": "https://github.com/Zayn1337-cpp",
"name": "Zayn1337-cpp"
}
}
]
},
"status": "success"
}
}About the Spuckwaffel API
Game Discovery and Navigation
All endpoints require a game hash identifier. Retrieve it via list_games, which accepts an optional engine filter ('Unreal-Engine-4' or 'Unreal-Engine-5') and returns an array of game objects with hash, name, engine, location, uploaded (millisecond timestamp), and uploader details. search_games accepts a query string and performs a case-insensitive name match across the catalog. get_recent_updates returns a feed of recent additions without requiring any parameters.
Class, Struct, and Enum Data
list_classes and list_structs each return sorted arrays of names for a given game hash. get_class_overview and get_struct_overview return the full member table for a named type, including size in bytes, a members array with per-member name, type, offset, and size fields, and an inheritance array of parent class names. get_class_inheritance extends this further, returning both the full inheritance_chain from the target up to the root ancestor and a direct_children array of classes that inherit from it. get_enum returns both a C++ enum class code string and a values array of [name, integer_value] pairs. Note that struct and enum data availability varies by dump — a name may appear in list_structs or list_enums but return empty members or values for some games.
Code Generation Endpoints
For each class and struct, two code-format endpoints are available: get_class_struct / get_struct_struct return a C++ constexpr namespace string showing member offsets, and get_class_mdk / get_struct_mdk return an MDK-style C++ definition including inheritance and member macros. These are returned as a single code string field, ready to paste directly into a modding or reverse-engineering project.
Functions, Offsets, and Global Search
list_functions returns all function group names for a game, and get_functions_for_class returns the full function array for a named group, with each entry carrying name, return_type, parameters, offset, and flags. get_offsets returns an array of global named offsets as hex strings; this field is optional per dump and may be empty. global_search queries across Classes, Structs, Members, and Enums within a single game hash, accepts query and an optional search_type of 'name' or 'type', and returns up to 100 results with type, name, and where relevant parent, member_type, and offset.
The Spuckwaffel API is a managed, monitored endpoint for dumpspace.spuckwaffel.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when dumpspace.spuckwaffel.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 dumpspace.spuckwaffel.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?+
- Building a game modding tool that resolves member offsets by class name using
get_class_overview - Generating C++ headers for a trainer or cheat SDK using
get_class_mdkandget_struct_mdkoutput - Tracking newly uploaded game dumps in an automated pipeline via
get_recent_updates - Looking up function signatures and offsets for a specific class with
get_functions_for_class - Walking the full inheritance tree of a UE class to understand object hierarchy via
get_class_inheritance - Searching for a specific member type or name across all classes in a dump using
global_searchwithsearch_type: 'type' - Cataloging global memory offsets for a target game build with
get_offsets
| 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 Dumpspace provide an official developer API?+
What does `global_search` actually search, and how many results does it return?+
global_search searches within a single game dump (identified by hash) across four data types: Classes, Structs, Members, and Enums. The optional search_type parameter lets you match against 'name' or 'type'. Results are capped at 100 and include a type field indicating which category matched, plus parent, member_type, and offset fields where applicable.Are all struct and enum details guaranteed to be populated for every game?+
list_structs and yet get_struct_overview may return an empty members array for that game. Similarly, get_enum may return an empty values array. Whether offset data is present depends on what the uploader included when the dump was submitted.Does the API cover Unity engine game dumps?+
engine filter on list_games only supports those two values. You can fork this API on Parse and revise it to add support for any Unity dump data that appears on the site.Can I retrieve the full C++ header for an entire game dump in a single call?+
get_class_struct or get_class_mdk, and per-struct via get_struct_struct or get_struct_mdk. To build a full header set you would call list_classes and list_structs first, then iterate. You can fork this API on Parse and add a batch endpoint that aggregates all code output for a game hash.