JavaScript Minifier — Compress JS Instantly in Your Browser

JavaScript Minifier is a free, browser-based tool that reduces the size of your JavaScript files by removing comments, collapsing whitespace, and optionally joining all lines into a single-line output. No uploads, no server round-trips, no account required.

The Problem

Every web project reaches a point where raw JS files need to go through a minifier. Locally that means installing Node.js tools, wiring up a build pipeline, and waiting for CI. For quick one-off tasks — cleaning up a legacy script, preparing a snippet to paste into a CMS, or stripping a vendor file of its verbose comments — that overhead is a speed bump developers don't need.

Browser-based minifiers solve this, but most of them upload your code to a server. For internal scripts, unreleased code, or anything business-sensitive, that is a non-starter.

How It Works

JavaScript Minifier processes code entirely in the browser using a tokenizer-aware parser. It correctly handles single-quoted strings, double-quoted strings, and template literals, so it never misidentifies // inside a string as a comment, and never strips the content of a tagged template expression.

Option 1 — Remove Comments

Strips both single-line (// ...) and block (/* ... */) comments. The parser tracks string boundaries, so content like const url = "https://example.com" is preserved intact.

Option 2 — Compress Whitespace

Collapses runs of spaces and tabs to a single space, trims leading and trailing whitespace from every line, and removes blank lines. The result is readable but compact — useful when you want smaller output that is still debuggable.

Option 3 — Single Line (Join Lines)

Removes all newline characters to produce a one-liner. Combine this with the other two options for maximum compression of simple scripts.

Key Features

• Tokenizer-aware parser — never corrupts string or template literal content
• Three independent options — combine freely for the result you need
• Real-time stats — original bytes, minified bytes, and exact saving percentage
• One-click copy — copy minified output to the clipboard instantly
• Download as .min.js — save the result without leaving the browser
• Live preview — output updates as you type; no "run" button needed
• 100% client-side — code never touches a server
• Dark mode support — matches system preference automatically

Technical Implementation

Core Technologies

• Next.js 16 with App Router and React 19
• TypeScript in strict mode
• Tailwind CSS v4 with OKLCH color tokens
• Framer Motion for animations
• Sonner for toast notifications
• Client-side rendering — zero external API dependencies

Minification Architecture

The core minifier is a single-pass tokenizer implemented in TypeScript. It walks the input character by character, tracking the current context:

• Inside a double-quoted string → emit as-is until the closing "
• Inside a single-quoted string → emit as-is until the closing '
• Inside a template literal → emit as-is, recursing into ${} expressions
• // outside a string → single-line comment, skip to end of line (if option enabled)
• /* outside a string → block comment, skip to */ (if option enabled)
• Whitespace character → emit a single space and skip remaining whitespace (if option enabled)
• Newline → drop entirely (join-lines option) or retain one newline (compress option)

A post-pass trims each line and removes blank lines when compress mode is active.

This approach is O(n) in input length, deterministic, and requires no AST — making it suitable for real-time processing of large files without blocking the UI.

Use Cases

Preparing Snippets for CMSes and No-Code Tools

Many CMSes (WordPress, Webflow, Squarespace) have a "custom code" box. Pasting 400 lines of commented JS into that box wastes space and looks messy. Run it through the minifier in 10 seconds and paste a compact, clean version.

Stripping Comments from Vendor Scripts

Open-source libraries often ship unminified source in their dist/ folder alongside the minified version. If you only have the unminified version, use the minifier to strip the comments before embedding.

Auditing What's Actually There

Removing comments first, then reading the minified output, is a fast way to understand what a script actually does without getting distracted by documentation comments and version headers.

Reducing Inline Script Size

Inline <script> tags in HTML should be kept small. Minifying a short utility function before inlining it reduces the initial HTML payload.

Build Pipeline Testing

Before wiring up a full webpack or esbuild pipeline, use the minifier to verify that a script minifies correctly. If the output runs as expected in the browser console, the script is minification-safe.

Results

For a typical developer-formatted JavaScript file:

• Comment removal alone typically reduces size by 15–35%
• Whitespace compression adds another 10–20%
• Join lines adds a further 3–8% (newline characters count)
• Combined: 25–50% reduction is common for hand-written code with documentation comments

---

Try it now: javascript-minifier.tools.jagodana.com