SQL Formatter

SQL copied out of application logs, ORM output or a colleague’s message usually arrives as one dense paragraph — technically valid, practically unreadable. This formatter restructures queries for human eyes: major clauses (SELECT, FROM, WHERE, GROUP BY, ORDER BY, JOIN, and friends) start on fresh lines, keywords are capitalised consistently, and nested parts are laid out so the logic of the query can be followed at a glance. It handles the everyday dialect-agnostic core of SQL — selects, inserts, updates, deletes, joins, subqueries in parentheses and CASE expressions at a structural level. Paste the tangle, get back a query you can review, debug and share, all without sending your schema details to a server.

Quick Answer: Paste a cramped SQL query and get it back with clauses on separate lines, capitalised keywords and readable structure — plus a one-line minified option.

Free Online Tool

From log-line spaghetti to a query a human can review.

Your SQL

Formatted SQL

How to Use the SQL Formatter

Paste your SQL query into the input box.
Press Format SQL to lay it out with clause breaks and capitalised keywords.
Read through the result — joins and conditions are now scannable.
Use Minify if you need the query back as a single line for embedding.
Copy the formatted SQL into your editor, ticket or documentation.

Key Features

Clause-aware line breaking for SELECT, FROM, WHERE, JOIN, GROUP BY, HAVING, ORDER BY, LIMIT and set operations.
Consistent keyword capitalisation for a professional finish.
Indenting for parenthesised subqueries.
One-click minify back to a single line.
Runs entirely in your browser — proprietary queries and table names stay private.

Best Practices and Tips

Format before you debug: most ‘mystery query’ problems become obvious once each condition sits on its own line.
Keep formatted queries in tickets and pull requests; reviewers can actually comment on structure.
Watch the WHERE layout for missing AND/OR logic — the formatter surfaces the conditions, but precedence is yours to verify.
If a formatted query suddenly looks wrong, it usually was wrong — formatting reveals, it does not invent.
For team consistency, agree on this clause-per-line style in your style guide so diffs stay readable.

Common Mistakes to Avoid

Expecting the formatter to fix invalid SQL — it structures valid queries; genuine syntax errors remain errors.
Assuming capitalisation changes behaviour; it does not (except inside quoted strings and identifiers, which the formatter leaves alone).
Pasting queries containing real customer data into tools generally — this one is local, but the discipline matters everywhere.
Over-trusting layout for correctness of JOIN conditions; an ON clause can be beautifully formatted and still join the wrong keys.

Frequently Asked Questions

Which SQL dialects does it support?

The formatter works on the standard SQL core shared by MySQL, PostgreSQL, SQL Server, SQLite and others — clauses and keywords are largely universal. Dialect-specific syntax passes through unformatted rather than breaking, so your query always survives the round trip.

Does formatting change what the query does?

No. Whitespace and keyword case (outside quoted text) are insignificant in SQL. The formatted query returns identical results; it is simply legible. Strings and quoted identifiers are preserved exactly.

Can it handle multiple statements?

Yes — statements separated by semicolons are formatted in sequence, each starting fresh, which makes migration scripts and seed files much easier to review.

What about really long generated queries?

ORM output with hundreds of columns formats comfortably. Extremely large scripts may take a moment, but nothing is uploaded, so the only cost is a second of local processing.

Will it indent subqueries?

Parenthesised sections are indented as blocks, so a subquery in FROM or an IN (SELECT …) list reads as the nested structure it is instead of a flat wall of text.