Does my SQL get uploaded, or does it run in my browser?

Nothing is uploaded. Formatting, minifying, and casing all run in your browser with JavaScript. Your schemas, table names, and queries never leave your device, so the tool works offline once the page loads.

What indentation and keyword casing can I set?

Indentation is adjustable from 1 to 8 spaces, defaulting to 2 spaces. Keyword casing has three modes: UPPERCASE (the common convention), lowercase, or Preserve, which leaves your original casing untouched.

Which SQL dialects does it support?

You can pick Standard SQL, MySQL, PostgreSQL, SQLite, T-SQL (SQL Server), or PL/SQL (Oracle). The formatter is whitespace and keyword based, so it preserves dialect-specific quoting like MySQL backticks or T-SQL square brackets exactly as you typed them.

Why format SQL queries at all?

Formatted SQL is easier to review and debug. Putting each clause on its own line and indenting JOIN conditions makes a stray AND, an accidental OR 1=1, or a wrong join key visible at a glance, which is how formatting reduces bugs in code review.

Is there a query size limit?

The tool accepts files up to 10MB. Typical application queries format instantly. Because all work happens in your browser, very large scripts depend on your device, but 10MB is the hard cap.

Does the formatter validate my SQL syntax?

No. It is a beautifier, not a parser, so it reformats whatever you paste without checking that the query is valid. It will not catch a missing comma or an unbalanced quote. Run the output against your database to confirm it executes.

SQL Formatter: Beautify & Clean Database Queries

Q: Is this SQL formatter free?

Yes. It is 100% free with no signup and no usage cap. Format and minify as many queries as you want, with files up to the 10MB limit.

Q: What does Minify mode remove?

Minify strips single-line (--) and multi-line (/* */) comments, collapses all whitespace to single spaces, and removes spaces around commas and parentheses. Use it to embed a compact query in application source or a config file.

SQL Formatter: Beautify and Minify Queries in Your Browser

A SQL formatter takes a cramped, one-line query and rewrites it with line breaks, consistent indentation, and uniform keyword casing so it is easy to read and review. Paste your SQL, set the indent from 1 to 8 spaces and casing to UPPERCASE, lowercase, or Preserve, then Format or Minify. It runs 100% in your browser, free, with no upload.

How to format a SQL query

Paste your SQL into the input box, or type a query directly.
Pick a dialect label — Standard, MySQL, PostgreSQL, SQLite, T-SQL, or PL/SQL — for your own reference.
Choose keyword casing: UPPERCASE for the common convention, lowercase, or Preserve to leave casing as-is.
Set the indent size anywhere from 1 to 8 spaces (the default is 2).
Press Format to beautify, or Minify to collapse the query to one line and strip comments.
Click Copy to send the result to your clipboard, or Download to save a .sql file.

How SQL formatting works (and why casing is safe)

SQL keywords are case-insensitive under the ANSI/ISO SQL standard, so SELECT, select, and Select all run identically. That is why a formatter can safely re-case keywords: it changes appearance, not behavior. The widely used SQL style guide by Simon Holywell recommends UPPERCASE reserved words (SELECT, WHERE, JOIN) with lowercase snake_case identifiers, so keywords stand out from your table and column names.

This tool is a beautifier, not a parser. It normalizes whitespace, inserts a newline before every major keyword (SELECT, FROM, WHERE, the JOIN family, GROUP BY, ORDER BY, and more), indents AND, OR, and ON conditions one level deeper, and tracks parenthesis depth to indent subqueries and CTEs. It re-cases only the keywords on its fixed list — your identifiers, string literals, and dialect quoting are left exactly as typed.

"Always capitalise the SQL reserved words... and make sure they are clearly separated from variable names."— Simon Holywell, SQL Style Guide

Worked examples: input → output

Format · UPPERCASE · 2-space indent

Input:

select id, name from users where active = 1 order by name

Output:

SELECT id, name
FROM users
WHERE active = 1
ORDER BY name

Format · JOIN with ON indented one level

SELECT u.id, o.total
FROM users u
INNER JOIN orders o
  ON u.id = o.user_id
WHERE o.status = 'paid'

Minify · comments and whitespace stripped

Input:

SELECT id  -- primary key
FROM   users

Output:

SELECT id FROM users

Edge case · keywords used as column names

The casing pass matches whole words from a fixed keyword list. A column literally named order, key, count, or end will be re-cased and pushed onto a new line as if it were a keyword. If you have identifiers that collide with reserved words, quote them (MySQL `order`, PostgreSQL "order", T-SQL [order]) or use Preserve casing to avoid surprises.

Identifier quoting by SQL dialect

Quoting an identifier (a table or column name) differs per database. The formatter preserves whichever character you use — this table is the reference for getting it right in each engine.

Dialect	Identifier quote	String literal quote	Example
MySQL / MariaDB	Backticks `	Single `'` (double also OK)	`order`
PostgreSQL	Double `"`	Single `'` only	"order"
T-SQL (SQL Server)	Brackets `[ ]`	Single `'`	[order]
SQLite	Any: `"`, `[ ]`, `	Single `'`	"order"
Standard / ANSI SQL	Double `"`	Single `'`	"order"

Source: ANSI SQL uses double quotes for identifiers and single quotes for string literals; MySQL adds backticks, T-SQL adds square brackets.

The dialect dropdown is a label, not a parser

Honest detail most SQL beautifiers gloss over: the dialect selector here changes nothing about the formatting logic. All six options (Standard, MySQL, PostgreSQL, SQLite, T-SQL, PL/SQL) run the same whitespace-and-keyword engine. It re-cases against a fixed list of roughly 90 reserved words and indents by clause and parenthesis depth — it does not understand backticks vs brackets, validate syntax, or rewrite dialect-specific constructs. The upside: your dialect-specific quoting and functions pass through untouched.

Two more real limits worth knowing: indentation is capped at 1–8 spaces (default 2), and input is accepted up to 10MB — far past any hand-written query. For deep schema or data validation, format here for readability, then run the SQL against your actual database.

Why formatted SQL reduces bugs in review

A query on one line hides its logic. Once each clause sits on its own line and JOIN conditions are indented, a reviewer can see at a glance whether the join key is correct, whether a WHERE filter is missing, or whether an unexpected OR widens the result set. Consistent casing and indentation also shrink diff noise, so code review focuses on real logic changes instead of whitespace. That is the same readability principle behind formatting JSON and XML before review.

Runs 100% in your browser

Your data never leaves your device. Formatting, minifying, and casing all run locally in JavaScript, and copy/download use your browser's native APIs — no uploads, nothing leaves your device. I tested this formatter on plain SELECT statements, multi-table JOINs, nested subqueries, CTEs, and minify mode with both -- and /* */ comments, across all three casing modes and indent sizes from 1 to 8. Output stays instant on typical application queries.

Frequently asked questions

Is this SQL formatter free?

Yes — 100% free with no signup and no usage cap. Format and minify as many queries as you want, up to the 10MB file limit.

Does my SQL get uploaded anywhere?

No. Everything runs in your browser with JavaScript, so your schemas and queries never reach a server. The tool works offline once the page loads.

Will it validate my SQL?

No — it is a beautifier, not a parser. It reformats whatever you paste without checking that the query is valid, so it will not catch a missing comma or unbalanced quote. Run the output against your database to confirm it executes.

What does Minify mode remove?

Minify strips single-line (--) and block (/* */) comments, collapses whitespace to single spaces, and removes spaces around commas and parentheses to produce a compact one-line query.