Does my source leave the browser?

No. Sorting runs locally. Code with proprietary internal package names stays on the device.

How are type-only imports handled?

import type and inline type specifiers are recognised and sorted alongside their value counterparts. They can optionally be grouped separately.

What about dynamic import() calls?

Dynamic imports are expressions, not statements, so they are left in place. Only top-level static imports are sorted.

js · ts · imports · grouped · live

Sort imports by group

Q: Will it merge duplicate imports?

Yes. Two imports from the same module are merged into a single statement with combined specifiers, matching common eslint-plugin-import behaviour.

Groups imports into node builtins, npm packages, scoped packages, alias paths, and relative paths — then alphabetises within each group. Blank lines between groups. Runs locally.

Sort Imports

Input

141 B

5 lines

Output

146 B

10 lines

Status

ready

live

Ratio

1.04×

out/in

input · js / ts

output · sorted imports

import fs from "fs";

import { z } from "zod";

import { Bar } from "@scope/pkg";

import { Foo } from "@/utils";

import { foo } from "./local";

Quick Start

How to sort imports

Each line matching import ... from '...' gets pulled out, classified by the path shape, sorted, and re-emitted with blank lines between groups.

01
Paste source
A .ts/.tsx/.js/.jsx file. Only the top-of-file import lines are touched.
Parsing runs through Prettier’s standalone bundle (or the language-specific equivalent) loaded lazily — no parser ships until the tool is opened.
importsPrettierASTstandalonelazy
input · sourceraw · AST
```
import a from 'a';
```
loaded · parsedAST · ready
02
Classifier runs
Path heuristics: node: builtins, scoped @org/pkg, alias @/ or ~/, relative ./..., everything else is npm.
Indent width, tab style, and print-width re-format through a memoised pass — switching 2 → 4 spaces never re-parses, only re-prints.
scanindentprint-widthmemoisedlive
groups · options5 · live
```
node | npm | @scope | @/ | ./
```
options applied · livelive
03
Watch them sort
Group order is fixed; within a group, paths are sorted alphabetically. Blank line between groups.
The formatter is deterministic and idempotent: running it twice produces byte-identical output, which keeps diffs and git noise to a minimum.
liveidempotentdeterministicdiff-cleanstable
out · formattedgrouped · ready
```
import fs from 'fs';

import z from 'zod';
```
formatted · liveidempotent
04
Copy or download
Paste back into your file or save as a new module. Source stays in your browser.
Download writes a Blob with the language-appropriate extension; copy uses navigator.clipboard.writeText so the output preserves all whitespace exactly.
exportclipboardbloblanguage MIMEclient-side
ok · copiedready · done
```
OK Copied
```
shipped · ready to shipsuccess

Pro tips

Formatting tips that keep diffs sane

Pick one config and pin it

Inconsistent formatting causes diff churn. Commit .prettierrc / .editorconfig and enforce in CI.

Format on save

Editor integration is faster feedback than a pre-commit hook. Use both for belt-and-braces.

Idempotency matters

Running the formatter twice should produce identical output. Test this on a representative file.

Match the language community

Default to community conventions: 2 spaces for JS/CSS, 4 for Python, tabs for Go. Fights over indent are a productivity tax.

Print-width drives wrapping

80, 100, and 120 are the common targets. Wider lines parse fast but review slower side-by-side.

Don’t mix formatters and linters

Prettier handles whitespace; ESLint handles correctness. Disable overlapping rules to avoid fight-club configs.

Use Cases

When to sort imports

Repo cleanup, code reviews, lint-pass prep.

Repo cleanup

Enforce one import order across a codebase. Idempotent: running the formatter twice produces byte-identical output, which is the foundation of a clean CI gate. Pair with a pre-commit hook so PRs arrive already formatted, focusing review on logic.

idempotent

Code reviews

Stable order means smaller, cleaner diffs. Pairs with EditorConfig + .prettierrc for end-to-end consistency. Whitespace-only changes vanish so reviewers see real diffs, and git blame stays honest about who wrote what.

CI-ready

Pre-eslint

Clean before eslint-plugin-import / simple-import-sort. Output respects your indent width, tab style, and print-width — settings carry over for repeat runs. Switching 2-space to 4-space costs nothing in CPU but standardises an entire codebase.

diff-clean

Monorepo migrations

Re-group when moving files across packages. Format-on-save is the fastest feedback loop; CI is the safety net. Together they make inconsistent indentation a thing of the past and free up review cycles for genuine concerns.

PR-friendly

Quick fix

Tidy one file before committing. Whitespace-only changes don't trigger downstream content-hash invalidations, so CDN cache keys and CI cache layers stay warm. Real changes get all the rebuild budget.

review-ready

Onboarding

Show new contributors the import convention. Pairs with linters (ESLint, Stylelint, pylint) that catch what formatting alone can't — bugs, unused imports, dead code. Each tool stays in its lane, and the codebase stays clean.

deterministic

FAQ

Frequently asked questions

Does it touch side-effect imports?

Only the import ... from '...' shape is matched. Bare import 'polyfill' lines stay in the non-import stream.

What about type-only imports?

import type { Foo } from 'x' matches the same regex and is sorted into the same groups.

Will it merge duplicate imports?

No. Duplicates are kept as-is and ordered next to each other.

Are comments preserved?

Comments above imports may be detached and moved into the non-import stream. Inspect output before saving.

Is anything sent to a server?

No — sorting runs locally in your browser tab.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!