Which minifier does this use?

Terser, the minifier used by many build tools. It runs in a background worker in your browser, so large files don't freeze the page and your code isn't uploaded.

Is minified code safe to use?

Terser only applies transformations that keep behaviour the same. Global names of classic scripts and exported names of modules are never renamed, so other scripts can still use them. Test minified code before deploying it, as with any build step.

What do Compress and Shorten names do?

Compress applies safe optimisations such as removing unreachable code and simplifying expressions. Shorten names renames local variables and functions to short names. Turn both off to only strip whitespace and comments.

What happens with syntax errors?

Nothing is produced: you get the error message with its line and column instead, so broken JavaScript is never passed on silently.

JavaScript Minifier

Compress JavaScript for production with Terser, right in your browser.

Input: 897 B
Minified: 470 B
Saved: 427 B (47.6%)

JavaScript input

/*! cart.js v1.4 | MIT License */

// Tax rate applied to every order
const TAX_RATE = 0.19;

/**
 * Calculate the total of a shopping cart, including tax.
 * @param {Array<{price: number, quantity: number}>} items
 */
export function calculateTotal(items) {
  const subtotal = items.reduce(
    (sum, item) => sum + item.price * (item.quantity ?? 1),
    0,
  );
  return Math.round(subtotal * (1 + TAX_RATE) * 100) / 100;
}

export async function loadCart(userId) {
  const response = await fetch(`/api/users/${userId}/cart`);
  if (!response.ok) {
    throw new Error(`Could not load the cart (HTTP ${response.status})`);
  }
  const data = await response.json();
  return data?.items ?? [];
}

export class Cart {
  #items = [];

  add(product, quantity = 1) {
    this.#items.push({ ...product, quantity });
    return this;
  }

  get total() {
    return calculateTotal(this.#items);
  }
}

Minified JavaScript

/*! cart.js v1.4 | MIT License */
export function calculateTotal(t){const a=t.reduce((t,a)=>t+a.price*(a.quantity??1),0);return Math.round(1.19*a*100)/100}export async function loadCart(t){const a=await fetch(`/api/users/${t}/cart`);if(!a.ok)throw new Error(`Could not load the cart (HTTP ${a.status})`);const r=await a.json();return r?.items??[]}export class Cart{#t=[];add(t,a=1){return this.#t.push({...t,quantity:a}),this}get total(){return calculateTotal(this.#t)}}

/*! cart.js v1.4 | MIT License */
export function calculateTotal(t){const a=t.reduce((t,a)=>t+a.price*(a.quantity??1),0);return Math.round(1.19*a*100)/100}export async function loadCart(t){const a=await fetch(`/api/users/${t}/cart`);if(!a.ok)throw new Error(`Could not load the cart (HTTP ${a.status})`);const r=await a.json();return r?.items??[]}export class Cart{#t=[];add(t,a=1){return this.#t.push({...t,quantity:a}),this}get total(){return calculateTotal(this.#t)}}

How to minify JavaScript

Paste your JavaScript on the left, or open a .js file.
The minified code appears on the right, with the original size, the new size and the percentage saved above it.
Keep Compress and Shorten names on for the smallest result, and choose what happens to comments.
Copy the result or download it as script.min.js.

Small scripts update as you type. For large files, press Minify JavaScript — the work happens in a background worker, so the page stays responsive.

Example

Original

// Greet every user by name
function greetUsers(userList) {
  const greetings = userList.map((user) => `Hello, ${user.name}!`);
  return greetings.join("\n");
}

Minified

function greetUsers(e){return e.map(e=>`Hello, ${e.name}!`).join("\n")}

The comment and whitespace are gone, the parameter userList became a single letter, and the temporary greetings variable was folded into the return statement. The function name greetUsers stays, because other scripts may call it.

Powered by Terser

The minifier is Terser, a widely used JavaScript minifier. It parses your code into a syntax tree, so it understands modern JavaScript — classes with private fields, async/await, optional chaining, nullish coalescing, template literals, regular expressions and ES modules — and it refuses code that doesn't parse: you get the error with its line and column instead of broken output.

Use cases

Shrinking a script for a site without a build step.
Minifying a bookmarklet or an inline snippet for an HTML page.
Checking how much a file would shrink before adding a build tool.

Related tools

To read minified code, use the JavaScript formatter. Shrink the rest of your page with the CSS minifier and the HTML minifier, and test scripts in a real page with the HTML compiler.

Frequently asked questions

Which minifier does this use?: Terser, the minifier used by many build tools. It runs in a background worker in your browser, so large files don't freeze the page and your code isn't uploaded.
Is minified code safe to use?: Terser only applies transformations that keep behaviour the same. Global names of classic scripts and exported names of modules are never renamed, so other scripts can still use them. Test minified code before deploying it, as with any build step.
What do Compress and Shorten names do?: Compress applies safe optimisations such as removing unreachable code and simplifying expressions. Shorten names renames local variables and functions to short names. Turn both off to only strip whitespace and comments.
What happens with syntax errors?: Nothing is produced: you get the error message with its line and column instead, so broken JavaScript is never passed on silently.