Loading JavaScript Deobfuscator...
Please wait a moment

How to Deobfuscate JavaScript - Step by Step Guide

Step 1

Input Your Obfuscated JavaScript

Let's make your obfuscated JavaScript readable! Need to protect code instead? Try our JavaScript Obfuscator. You have several convenient options:

•
Paste directly: Copy your obfuscated or minified JavaScript and paste it into the input editor
•
Upload a file: Click "Upload" to select an obfuscated .js file from your computer
•
Try the sample: Click "Sample" to see how deobfuscation works

Example: Obfuscated JavaScript Input

Here's obfuscated JavaScript that's hard to read:

function _0x2a4b(_0x1c5d,_0x3e7f){if(_0x1c5d["\x6c\x65\x6e\x67\x74\x68"]<0x3)return![];return _0x3e7f["\x6c\x65\x6e\x67\x74\x68"]>=0x8;}
Step 2

Automatic Deobfuscation & Formatting

The deobfuscator makes your ECMAScript code readable! The tool automatically applies multiple techniques:

•
Beautifies code: Adds proper indentation and line breaks for readability
•
Decodes strings: Turns \x and \u escapes back into readable text
•
Simplifies tricks: 0x3 becomes 3, ![] becomes false and obj["length"] becomes obj.length. Variable names stay as they are.

Example: Deobfuscated Output

The same code, now deobfuscated and readable:

function _0x2a4b(_0x1c5d, _0x3e7f) {
  if (_0x1c5d.length < 3) return false;
  return _0x3e7f.length >= 8;
}
Step 3

Review and Understand the Code

Analyze the deobfuscated code with improved readability:

•
Syntax highlighting: Color-coded output makes code structure clear
•
Line numbers: Easy navigation and reference to specific code sections
•
Proper structure: Indentation shows function nesting and code flow
Step 4

Export Deobfuscated Code

Save your readable JavaScript for analysis or documentation:

•
Copy to clipboard: One-click copying for easy use in your projects
•
Download as file: Save deobfuscated code as a .js file
•
Further beautify: Use with our JavaScript Beautifier for additional formatting

Frequently Asked Questions

What is JavaScript deobfuscation?

JavaScript deobfuscation is the process of converting obfuscated or minified code back into a more readable format. It includes beautifying the code structure, decoding encoded strings, and simplifying complex patterns to make the code easier to understand and analyze.

Can this tool fully recover original variable names?

No, deobfuscation cannot fully recover original variable and function names that were changed during obfuscation. However, it can decode string literals, improve code formatting, and make the logic easier to follow. Original names are permanently lost unless comments or hints remain in the code.

Is it legal to deobfuscate JavaScript code?

Deobfuscating code for learning, debugging your own code, or security research is generally legal. However, reverse engineering proprietary software to steal intellectual property or circumvent licensing may violate terms of service or copyright laws. Always respect software licenses and intellectual property rights.

Will deobfuscated code work the same as obfuscated code?

It should. Only the spelling changes: escapes become readable characters, 0x1f becomes 31, ![] becomes false, obj["length"] becomes obj.length, and the code gets line breaks and indentation. One catch: some obfuscators add self-defending checks that compare a function's source text, and those can trip once the code is re-indented.

Can I deobfuscate heavily obfuscated code?

Partly. You get readable strings and sane formatting, which is often enough to see what a script is up to. String-array lookups such as _0x4f2e(0x1a3), control-flow flattening (the big while/switch loops) and dead code are not undone here, so those still need untangling by hand.

How does this differ from a JavaScript beautifier?

A JavaScript beautifier only formats code structure with proper indentation and spacing, while a deobfuscator goes further by decoding encoded strings (hex, unicode), converting obfuscated number formats, and attempting to simplify intentionally obscured code patterns. For simple minified code, try the JavaScript Beautifier.

Can this deobfuscate code from javascript-obfuscator tool?

Partly. Output from the javascript-obfuscator library comes out much cleaner: escaped strings, hex numbers and the ![] tricks are all rewritten. If the string-array option was on, most strings are fetched through a decoder function at runtime, and those calls stay as they are, because this page never runs your code.

What obfuscation techniques does this tool handle?

Strings written with \x and \u escapes are decoded (control characters and invisible or right-to-left override characters stay escaped, so you can still spot them), hex number literals like 0x1f become decimal, ![], !![], !0 and !1 become false or true, obj["name"] becomes obj.name, and everything is re-indented. Variable names, string arrays and control-flow flattening are left alone. If the input is not valid JavaScript you get the line and column of the problem instead of a guess.

Is my JavaScript code secure when using this tool?

Your code stays in your browser tab. It is not uploaded anywhere, and it is not executed either: the page only parses the text and prints it back, so pasting a suspicious script here is safe. The flip side is that eval-packed code like eval(function(p,a,c,k,e,d){...}) gets formatted but not unpacked.

Is the JavaScript deobfuscator completely free?

Yes, it is free and there is nothing to sign up for. There is no fixed size limit, but everything runs in your browser, so a multi-megabyte bundle can take a few seconds.

Understanding JavaScript Obfuscation Techniques

JavaScript obfuscation uses various techniques to make code difficult to read and understand. Learning about these methods helps you better deobfuscate and analyze obfuscated code. For more on code obfuscation concepts, see software obfuscation. Here are the most common obfuscation techniques you'll encounter:

String Encoding

One of the most common obfuscation methods. Readable strings are converted into hex-encoded (\\x notation), or unicode escape sequences (\\u notation). This tool decodes both back into readable text. Base64 strings are left as they are, because telling them apart from ordinary text would be guesswork.

Example:

"\\x68\\x65\\x6c\\x6c\\x6f" → "hello"

Variable Name Mangling

Meaningful variable and function names are replaced with short, cryptic names like _0x2a4b, _0x1c5d, or single letters. While this technique makes code harder to understand, the deobfuscator can still format the code structure properly. Unfortunately, original variable names cannot be recovered.

Example:

calculateTotal → _0x2a4b

Number Obfuscation

Decimal numbers are converted to hexadecimal format (0x prefix), making simple values harder to recognize. The deobfuscator automatically converts these back to readable decimal numbers for easier understanding.

Example:

0x3 → 3, 0x8 → 8, 0xFF → 255

Control Flow Flattening

Linear code execution is transformed into complex switch-case statements or nested conditionals, making the program flow difficult to follow. This advanced technique requires careful manual analysis even after deobfuscation and beautification.

Dead Code Injection

Meaningless code that never executes is inserted throughout the program to increase complexity and confuse readers. While deobfuscation can format this code properly, identifying and removing dead code requires understanding the program logic.

Deobfuscation Best Practices

  • •Start by using this deobfuscator to decode strings and beautify structure
  • •Look for patterns in variable names to understand code organization
  • •Use browser developer tools to debug and step through complex code
  • •For heavily obfuscated code, try the JavaScript Formatter after deobfuscation
  • •Remember that deobfuscation is legal for learning, debugging your own code, and legitimate security research