Skip to content
Aback Tools Logo

JavaScript Variable Name Deobfuscator

Analyze obfuscated variable, function, and class names in JavaScript code and get meaningful name suggestions based on usage context. Paste your code, review suggestions with confidence ratings, edit or accept them, build a rename mapping, and preview the deobfuscated code — all free, private, and no signup required.

JavaScript Variable Name Deobfuscator

Paste JavaScript code with obfuscated variable names (a, b, _0x, etc.) and get meaningful name suggestions based on usage context. Edit suggestions, build a rename mapping, and preview the deobfuscated code.

Live analysis — results update as you type

Detected Obfuscated Identifiers (15)

e×4High confidence
length
c) { var d = []; for (var e = 0; e < b.length; e++) { ... var d = []; for (var e = 0; e < b.length; e++) { var f ... for (var e = 0; e < b.length; e++) { var f = b[e]; if
i×4High confidence
length
a) { let r = []; for (let i = 0; i < data.length; i++) { ... let r = []; for (let i = 0; i < data.length; i++) { let ... (let i = 0; i < data.length; i++) { let v = data[i];
v×4High confidence
length
< data.length; i++) { let v = data[i]; if (v.status = ... let v = data[i]; if (v.status === 'active') { ... active') { r.push({ id: v.id, val: v.amount * 1.1 });
b×3High confidence
length
function a(b, c) { var d = []; for (va ... d = []; for (var e = 0; e < b.length; e++) { var f = b[ ... b.length; e++) { var f = b[e]; if (f > 10) { d
d×3Medium confidence
first
function a(b, c) { var d = []; for (var e = 0; e < b ... b[e]; if (f > 10) { d.push(f * 2); } } retu ... sh(f * 2); } } return d; } function _0x42(x, y) {
f×3High confidence
length
e < b.length; e++) { var f = b[e]; if (f > 10) { ... ) { var f = b[e]; if (f > 10) { d.push(f * 2); ... if (f > 10) { d.push(f * 2); } } return d; }
data×3Medium confidence
length
urn z * 1.5; } function proc(data) { let r = []; for (let i ... r = []; for (let i = 0; i < data.length; i++) { let v = da ... ta.length; i++) { let v = data[i]; if (v.status === 'act
r×3High confidence
id
function proc(data) { let r = []; for (let i = 0; i < d ... .status === 'active') { r.push({ id: v.id, val: v.amoun ... * 1.1 }); } } return r; }
x×2Medium confidence
first
return d; } function _0x42(x, y) { const z = x + y; re ... ion _0x42(x, y) { const z = x + y; return z * 1.5; } fun
y×2Medium confidence
first
eturn d; } function _0x42(x, y) { const z = x + y; retur ... _0x42(x, y) { const z = x + y; return z * 1.5; } functio
z×2Medium confidence
data
unction _0x42(x, y) { const z = x + y; return z * 1.5; } ... { const z = x + y; return z * 1.5; } function proc(data)
a×1Medium confidence
accumulator
function a(b, c) { var d = []; for (
c×1Medium confidence
config
function a(b, c) { var d = []; for (var e
_0x42×1Low confidence
hexString__0x
} } return d; } function _0x42(x, y) { const z = x + y;
id×1High confidence
id
== 'active') { r.push({ id: v.id, val: v.amount * 1.1 })

Manual Rename

→

Add custom mappings for variables the detector may have missed.

Privacy Guarantee

All analysis runs entirely in your browser. Your code never leaves your device — no uploads, no API calls, no tracking.

Features

Auto-Detection of Obfuscated Names

Scans your code for short names (a, b, i, j), hex-prefixed identifiers (_0x...), underscores-only variables, and other patterns common in minified and obfuscated JavaScript.

Context-Aware Name Suggestions

Each detected variable is analyzed in its usage context — nearby keywords like count, user, id, error, and result determine the suggested meaningful name with a confidence rating.

Interactive Rename Workflow

Accept, edit, or override suggestions for each identifier. Build a complete rename mapping table showing original → deobfuscated names — no manual searching required.

Deobfuscated Code Preview

After mapping variables, preview the code with all original names replaced by your chosen deobfuscated names. Copy the transformed code or download the mapping as JSON.

Use Cases

Reverse Engineering

When analyzing obfuscated third-party scripts, quickly identify variable usage patterns and rename them to understand what the code does without tracing every reference.

Debugging Minified Code

Browser error stack traces often point to minified production code. Deobfuscate variable names to make stack traces and debugging sessions more readable and actionable.

Code Migration & Auditing

Legacy codebases or acquired assets may have obfuscated variable names. Deobfuscate before refactoring to understand the original intent and avoid introducing bugs.

Learning & Education

Students learning JavaScript can paste minified or obfuscated code to see how variables map to their purposes, building understanding of scope, closures, and naming conventions.

Malware & Security Analysis

Security researchers analyzing potentially malicious JavaScript can deobfuscate variable names to understand data flows, API interactions, and payload construction more rapidly.

Pre-Deployment Review

Before shipping obfuscated code, run it through the deobfuscator to verify no sensitive variable names or internal identifiers are leaking through the obfuscation.

About JavaScript Variable Name Deobfuscation

What Is Variable Name Deobfuscation?

Variable name deobfuscation is the process of replacing short, meaningless, or encoded identifier names in JavaScript code with meaningful, descriptive names that convey their purpose. Obfuscated names like a, _0x42, or ____ are replaced with suggestions like userCount, apiToken, or resultData based on how they are used.

How the Deobfuscator Works

The tool parses your JavaScript code to extract all identifier-like tokens. It filters out JavaScript keywords, standard library names, and property access chains. Each remaining identifier is scored by its likelihood of being obfuscated — short length, hex prefixes, underscore-only patterns, and non-descriptive names rank highest. A context window around each usage is analyzed: nearby keywords (e.g., “count” suggests a counter, “user” suggests a user object) determine the suggested replacement.

Confidence Levels

Each suggestion includes a High, Medium, or Low confidence rating. High confidence means the surrounding context contains a strong, unambiguous keyword match. Medium means a partial or indirect match.Low means the name appears obfuscated but the context provides limited clues — these suggestions are best-guesses based on common conventions.

Privacy & Limitations

This deobfuscator runs entirely in your browser. Your code never leaves your device. It is designed for single-file analysis and works best with standalone JavaScript. For production-grade deobfuscation across multiple files, consider using a dedicated desktop tool like de4js or source map reconstruction. The tool analyzes identifier names and usage patterns only — it does not track runtime state or data flow.

Frequently Asked Questions