decomp APIdecomp.me ↗
Access decomp.me decompilation projects, user contributions, and site statistics via 4 endpoints. Retrieve scratch details, source code, compiler flags, and scores.
What is the decomp API?
The decomp.me API exposes 4 endpoints for querying decompilation scratch projects, user contributions, and site-wide statistics on decomp.me. The get_scratch_detail endpoint returns full project data including C source code, compiler flags, target platform, match score, and version family history — giving programmatic access to the same data visible on individual scratch pages.
curl -X GET 'https://api.parse.bot/scraper/28e2a231-d752-4389-890d-c31ca235a587/get_recent_scratches?ordering=-creation_time&has_owner=true&page_size=5' \ -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 decomp-me-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.
from parse_apis.decomp_me_api import DecompMe, ScratchOrdering
client = DecompMe()
# Get site-wide statistics
stats = client.statses.get()
print(stats.scratch_count, stats.asm_count, stats.github_user_count)
# Browse recent scratches sorted by newest first
for scratch in client.scratchsummaries.list_recent(ordering=ScratchOrdering.NEWEST, page_size="5", limit=5):
print(scratch.slug, scratch.name, scratch.platform, scratch.score, scratch.max_score)
# Drill into full details for the first one
detail = scratch.details()
print(detail.source_code[:80], detail.compiler_flags, detail.language)
break
# Look up a specific user's contributions
user = client.user(username="sonicdcer")
for contrib in user.contributions(ordering=ScratchOrdering.RECENTLY_UPDATED, limit=3):
print(contrib.slug, contrib.name, contrib.compiler, contrib.creation_time)
Retrieve the latest decompilation projects and site activity. Returns a paginated list of scratch projects sorted by the specified ordering. Each result is a summary containing slug, owner, name, platform, compiler, score, and timestamps. Paginates via cursor.
| Param | Type | Description |
|---|---|---|
| cursor | string | Opaque pagination cursor for fetching subsequent pages. |
| ordering | string | Sort order for results. |
| has_owner | string | Filter for scratches with a registered owner. Accepted values: 'true', 'false'. |
| page_size | string | Number of results per page. |
{
"type": "object",
"fields": {
"next": "string or null, cursor URL for next page of results",
"results": "array of ScratchSummary objects",
"previous": "string or null, cursor URL for previous page of results"
},
"sample": {
"data": {
"next": "https://decomp.me/api/scratch?cursor=cD0yMDI2LTA2LTEwKzIwJTNBMTAlM0EyOC4zOTUyMDElMkIwMCUzQTAw&has_owner=true&ordering=-creation_time&page_size=5",
"results": [
{
"name": "func_8009D2B0",
"slug": "ypP2f",
"owner": {
"id": 8750703,
"is_admin": false,
"username": "roengstrom",
"github_id": 26772201,
"is_online": true,
"is_anonymous": false
},
"score": 2425,
"parent": null,
"preset": null,
"compiler": "gcc2.7.2-cdk",
"platform": "ps1",
"best_fork": null,
"libraries": [],
"max_score": 28700,
"last_updated": "2026-06-11T05:33:12.816621+09:00",
"creation_time": "2026-06-11T05:32:52.091966+09:00",
"match_override": false
}
],
"previous": null
},
"status": "success"
}
}About the decomp API
Endpoints and Data Coverage
The API covers four areas of decomp.me. get_recent_scratches returns a paginated list of scratch projects sortable by -creation_time or -last_updated, with optional filtering by whether a scratch has a registered owner via the has_owner parameter. Each result includes the scratch slug, owner, name, platform, compiler, score, max_score, creation_time, and last_updated. The page_size parameter controls how many results appear per page.
Scratch Detail
get_scratch_detail accepts a slug (obtainable from get_recent_scratches results) and returns the complete record for that project: the source_code string containing the C decompilation attempt, the context header used for compilation, the compiler identifier, the platform tag (e.g. n64, gc_wii), and a family array listing related scratch version summaries. The score and max_score integers together indicate how closely the compiled output matches the target assembly.
User Contributions and Site Stats
get_user_contributions takes a GitHub/decomp.me username and returns that user's scratch projects in the same paginated format as get_recent_scratches, with the same ordering and page_size controls. get_stats requires no parameters and returns three site-wide counters: asm_count (total assembly instructions across all scratches), scratch_count (total projects), and github_user_count (registered users). These are useful for tracking platform growth over time.
The decomp API is a managed, monitored endpoint for decomp.me — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when decomp.me 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 decomp.me 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?+
- Monitor newly created or recently updated decompilation scratches using
get_recent_scratcheswith-last_updatedordering. - Build a leaderboard by collecting
scoreandmax_scorefields from multiple scratches to rank contributors by match quality. - Audit a specific contributor's output by fetching all their scratches via
get_user_contributionswith their GitHub username. - Diff decompilation approaches across related scratch versions using the
familyarray returned byget_scratch_detail. - Track platform-specific activity by filtering
get_recent_scratchesresults by theplatformfield (e.g.n64,gc_wii). - Aggregate site growth metrics over time by polling
get_statsfor changes inscratch_countandgithub_user_count. - Extract C source code and compiler context from a scratch using
source_codeandcontextfields for offline analysis.
| 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 decomp.me have an official developer API?+
What does `get_scratch_detail` return beyond what the list endpoints show?+
get_scratch_detail adds four fields not present in list results: source_code (the full C decompilation text), context (the C header context passed to the compiler), the family array of related scratch version summaries, and the compiler string. The list endpoints only carry summary fields like slug, name, score, max_score, platform, and timestamps.Can I filter scratches by platform or compiler?+
get_recent_scratches supports filtering by has_owner and sorting by ordering, but platform and compiler filtering is not exposed as a parameter. You can retrieve paginated results and filter on platform or compiler client-side using the fields present in each result object. You can also fork this API on Parse and revise it to add a platform or compiler filter endpoint.Is assembly output or diff data available from the API?+
source_code (C source), context, score, and max_score, but does not expose the compiled assembly output or the line-by-line diff between the attempt and the target. You can fork this API on Parse and revise it to add an endpoint that surfaces assembly diff data if decomp.me exposes it via their public API.How fresh is the data returned by these endpoints?+
get_recent_scratches sorted by -last_updated returns projects in the order they were most recently edited, so the freshness of any given scratch depends on when its author last saved changes. There is no delta or webhook mechanism — callers need to poll periodically to detect updates.