Default transformations with modest output growth. Test the generated code in your application.

Source codeinput.js
Obfuscated output
Work with your result
0%
Size Change
0 B
Generated Size
0ms
Generation Time
Browser
Output Target

Start with valid JavaScript

Check source syntax before generating your result.

Compact Code
Significantly reduces code size by removing unnecessary whitespace and formatting.
Self Defending
Adds engine checks for some formatting changes. Requires compact output and can break if a later build step rewrites the result.
Simplify Code
Applies various transformations to simplify code before obfuscation.
Numbers to Expressions
Replaces literal numbers with equivalent mathematical expressions.
Identifier Names Generator
Defines the strategy for generating replacement identifier names.
Rename Globals
Renames global variables and function declarations. Use with caution.
Source Map
Creates a source map file for debugging the obfuscated code.
Unicode Escape Sequence
Transforms string literals to unicode escape sequences.
Target
Adjusts obfuscation for specific JavaScript environments.
Split Strings
Splits string literals into chunks to enhance obfuscation.
Transform Object Keys
Transforms object keys into variables or expressions.
Reserved Name Patterns
Comma-separated regular expressions. Anchor exact names with ^ and $. Escape special characters: ^\$$ reserves only the literal name $.
Comma-separated regular expression patterns matched against identifier names.
String Array
Moves string literals to a special array and replaces with calls to array indexing.
String Array Threshold
0 (None)0.751 (All)
Adjusts the probability of a string being moved to the string array.
String Array Encoding
Apply encoding to the strings in the string array. Multiple encodings stack.
String Array Rotation
Randomly shifts the string array items on each call, making reverse engineering harder.
String Array Shuffle
Randomly shuffles the string array items, further increasing obfuscation.
String Array Calls Transform
Transforms calls to the string array with various expressions.
Control Flow Flattening
0 (None)0.751 (All)
Dramatically obfuscates code structure. Significantly impacts performance.
Dead Code Injection
Injects blocks of irrelevant code to confuse reverse engineering tools.
Debug Protection

One-time debug protection only. Recurring debugger intervals are disabled to avoid accumulating timers.

Makes debugging extremely difficult by monitoring and responding to debugger presence.
Disable Console Output
Disables console.log, console.info, console.error, and other console methods.
Domain Lock
Enter one domain per line. Code will only execute on specified domains.
Domain Lock Redirect
URL to redirect to when code execution is attempted on unauthorized domains.

Supported transformations

The installed engine supports identifier renaming, object-key transformation, number expressions, string arrays, control flow flattening and dead code injection. Configure these in Basic, Advanced, Strings and Control Flow.

Function reordering, function outlining, object method extraction, variable concealing, string concealing and literal expressions are unavailable in this engine version.

Password Protection
Password strength will be shown here

Encrypts the payload with AES-256-GCM. Execution asks for the password and requires a secure context with Web Crypto. Execution is asynchronous; dependent scripts must wait for the payload. This client-side gate does not replace server authentication; browser users can inspect decrypted code.

Code Integrity Check

Checks the exact embedded payload against its SHA-256 checksum before execution. Verification and execution are asynchronous. This detects accidental changes; an attacker can replace both the payload and checksum. It does not establish authenticity.

Environment Protection
Automation Signal Check
Context Lock

Checks browser signals once before running the payload. Automation and iframe checks are bypassable compatibility controls and can block legitimate test or embedded environments.

Code Expiration
Expires at the end of the selected day in the executing device’s local timezone. The device clock is user-controlled.

Checks the device clock before executing the payload. Use server-side licensing for enforceable expiration.

Analysis Results
0 KB
Original Size
0 KB
Obfuscated Size
0%
Size Increase
Not measured
Protection Strength
Not measured
Runtime Impact
0
Complexity Score

Detailed Analysis

Select Analyze code to compare your source with the generated output. Runtime performance requires testing in your application.

Obfuscation changes code readability. It does not prevent reverse engineering or replace server-side authentication. Keep secrets on your server and test generated code before deployment. Only obfuscate code you own or have permission to modify, and never use it to hide malicious code; see our Terms of Service.

THE DETAILS

JavaScript obfuscation guide

Practical guidance for choosing settings and shipping your result.

How to obfuscate JavaScript

  1. Paste code in Original Code, import a project, or load the sample.
  2. Select a preset. Start with Default or Low, then add options only where needed.
  3. Validate the input and click Obfuscate code. A failed transformation leaves the existing result available and reports the error.
  4. Test the result in your application, including asynchronous behavior, global APIs and every target browser.
  5. Copy or download JavaScript, an HTML harness, or a project backup. A source map, when supported by the selected configuration, is exported separately.

Projects and privacy

Code transformations run in your browser. Saved projects and preferences use this browser's local storage. They are not shared between browsers or devices. Storage can be unavailable, full or cleared; export a JSON project backup for important work. Project backups can include source code and settings, so store and share them carefully.

Use Ctrl+S (Command+S on macOS) to save. Auto-save persists edits when enabled. Creating or switching projects keeps source and result associated with the correct project.

What is a JavaScript obfuscator?

A JavaScript obfuscator rewrites working code into an equivalent version that is harder for people to read. It renames identifiers, encodes strings and can restructure control flow, while aiming to keep the same behavior. Minification, by contrast, primarily reduces code size. Neither provides a guarantee against reverse engineering, AI analysis, copying or modification. Never embed API secrets or trusted authorization decisions in browser code.

Test real application behavior after every configuration change. Renaming public properties, changing global identifiers and intensive control flow transformations can affect integration contracts and performance.

GOOD TO KNOW

JavaScript obfuscator FAQ

No. Obfuscation makes source code harder to read, but code delivered to a browser can be inspected and reverse engineered. Keep secrets and authorization checks on a server.

Code transformation runs locally in your browser. Project data is stored in this browser when you save it. Download a project backup before clearing browser data or moving devices.

It can increase code size and runtime cost. Parse timing only measures parsing; it does not run your code. Test the generated result in your application and target browsers.

No. AES-256-GCM encrypts the payload until the correct password is supplied, but decrypted code can be inspected in the browser. Use server-side authentication for access control.

Use a current browser for the editor. Password and checksum wrappers require HTTPS or localhost and Web Crypto. Browser-only wrappers are unavailable for module, Node and no-eval targets; test generated output on every required runtime.

Obfuscate your JavaScript

Start with a sample or paste your source, then choose a preset and validate the generated result.