Heapdump Analyzer
Inspect Node / V8 heap snapshots in the browser, summarize node counts, dominant object types, and first-pass memory leak hints.
Drag & drop or click to upload
Supports .heapsnapshot, .heapdump, and JSON snapshot exports
Use heap snapshots to move from “memory is high” to “these object families dominate the heap”
Heap dumps are where memory leak debugging becomes concrete. Instead of guessing whether growth comes from arrays, strings, detached objects, queues, or retained caches, a snapshot gives you a structural picture of the heap at one point in time. A browser-side analyzer is useful for the first pass: count nodes, inspect dominant object types, and decide what to inspect next in DevTools or another retaining-path viewer.
- Upload a Node heapdump or Chrome heapsnapshot file generated close to the moment memory pressure became suspicious.
- Read the high-level counts first: nodes, strings, and dominant node families often expose the broad shape of the problem.
- Use the top node types and memory findings to decide whether to inspect caches, queues, payload duplication, detached graphs, or runaway buffering next.
- Open the same snapshot in Chrome DevTools or another heap viewer to follow retaining paths and dominators for the actual leak root cause.
Why first-pass heap analysis matters
A full heap snapshot can be intimidating because the data volume is large and the debugging UI is often even larger. Engineers frequently need a simpler first question answered before anything else: what kinds of objects dominate this heap? If arrays, strings, closures, or code objects are clearly overrepresented, the next investigative path becomes much more focused.
That is why a lightweight heap analyzer has value even alongside Chrome DevTools. It turns an overwhelming artifact into a short shortlist of likely pressure points.
How to use snapshot summaries correctly
A dominant node type is not automatically a bug. Arrays may be expected in an event pipeline; strings may be expected in a search index. The right use of a summary is comparative: compare snapshots across time, compare before and after a suspected leak trigger, and use the dominant types to decide which retainers or code paths deserve deeper inspection.
The page should therefore position itself as triage and direction-finding. Leak root cause still depends on retaining paths, dominators, and application context.
Best use cases
- First-pass triage of Node.js memory incidents before deeper leak debugging begins.
- Comparing snapshots to see whether arrays, strings, or other node families are growing disproportionately.
- Teaching teams how to read heap artifacts at a high level before diving into full retaining-path analysis.
Common mistakes to avoid
- A large node family is a clue, not a verdict. Business context still decides whether the growth is expected or pathological.
- One snapshot alone rarely proves a leak. Comparisons across time are usually much more reliable.
- Heap dumps can contain application data and user payload remnants, so handle them like sensitive operational artifacts.
Related tools
Move directly into the next step instead of leaving the site to do adjacent work elsewhere.
Coredump Analyzer
Upload a core dump for browser-side heuristic analysis: file format, crash signals, likely fault classes, and triage hints before you open gdb.
JSON Formatter / Validator
Format, minify and validate JSON data
Mock Data Generator
Turn JSON samples into realistic mock data arrays with smart field inference for email, avatar, ids, totals, timestamps, and more.
Unix Timestamp Converter
Convert between Unix timestamps and human-readable dates
FAQ
Can this pinpoint the exact leak source?
Not by itself. It summarizes the snapshot so you know where to look next. Exact leak analysis still needs retaining paths and dominator inspection in a dedicated heap viewer.
Why show dominant node types first?
Because they quickly reveal whether the heap is dominated by arrays, strings, closures, or other object families, which narrows the next debugging step.
Should I capture more than one heap snapshot?
Yes. Comparing snapshots before and after the suspected leak trigger is usually much more informative than inspecting a single isolated snapshot.