formatter.input (SQL)
Loading Editor...
formatter.output (SQL)
Loading Editor...
You've inherited a 200-line SQL query. No indentation. No line breaks.
JOINs buried inside subqueries buried inside CTEs, all strung together on three lines. You need to understand it — fast. Paste it above. One click. Readable SQL.
Our free SQL formatter transforms dense, unreadable query strings into clean, consistently indented SQL that you can actually reason about — whether you're debugging a slow query, writing documentation, or reviewing a colleague's code.
Most developers know they should write readable code. Somehow SQL gets a pass. Queries get written under pressure, copied from Stack Overflow, or auto-generated by ORMs. The result is codebases full of SQL that looks like this:
SELECT u.id,u.name,u.email,o.order_id,o.total,p.product_name FROM users u LEFT JOIN orders o ON u.id=o.user_id LEFT JOIN order_items oi ON o.order_id=oi.order_id LEFT JOIN products p ON oi.product_id=p.id WHERE u.created_at>'2024-01-01' AND o.status='completed' ORDER BY o.total DESC LIMIT 100SELECT
u.id,
u.name,
u.email,
o.order_id,
o.total,
p.product_name
FROM
users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.order_id = oi.order_id
LEFT JOIN products p ON oi.product_id = p.id
WHERE
u.created_at > '2024-01-01'
AND o.status = 'completed'
ORDER BY
o.total DESC
LIMIT 100Formatting SQL isn't just about aesthetics. It directly affects how quickly you can debug, how well your team can review each other's code, and how easily new developers can understand existing queries.
Paste any SQL query and get clean, indented code. Keywords are capitalized. Clauses start on new lines. Nested logic is clearly structured.
Supports MySQL, PostgreSQL, SQL Server (T-SQL), Oracle (PL/SQL), SQLite, and Standard ANSI SQL. Handles dialect-specific syntax quirks.
Built for queries that hurt your eyes: deeply nested subqueries, multi-level CTEs, long JOIN chains, CASE expressions, and window functions.
Keywords like `SELECT`, `FROM`, `WHERE` are automatically capitalized, following standard conventions to distinguish syntax from identifiers.
Need to inline a query? Minify strips all formatting and whitespace to produce a compact single-line SQL string.
Copy formatted SQL to your clipboard or download as a `.sql` file for use in docs, source control, or migrations.
Understanding the anatomy of complex SQL is the first step to reading it confidently. Here's how our formatter handles major structures:
CTEs break complex logic into named steps. Our formatter indents each CTE body consistently and places each one in its own block.
WITH monthly_revenue AS (
SELECT
DATE_TRUNC('month', order_date) AS month,
SUM(total_amount) AS revenue
FROM orders
GROUP BY 1
)
SELECT * FROM monthly_revenue;Dense syntax like `RANK() OVER (PARTITION BY ...)` is formatted to make the analytic logic readable.
SELECT
department,
salary,
RANK() OVER (
PARTITION BY department
ORDER BY salary DESC
) AS salary_rank
FROM employees;Aligns `WHEN`, `THEN`, and `ELSE` branches to turn complex conditional logic into a readable decision table.
SELECT
order_id,
CASE
WHEN total >= 1000 THEN 'High'
WHEN total >= 500 THEN 'Mid'
ELSE 'Low'
END AS tier
FROM orders;Nested subqueries are indented to visually represent depth, making hierarchy obvious.
`SELECT`, `FROM`, `WHERE`. Visually separates syntax from identifiers. The most impactful rule for readability.
Starts new lines for `FROM`, `WHERE`, `JOIN`. Makes it easy to comment out single clauses while debugging.
Always use `INNER JOIN`, `LEFT JOIN` instead of implicit comma joins. Communicates intent clearly.
Use short, meaningful aliases (`u` for `users`). Avoid ambiguous single letters if possible.
Formatted SQL isn't just easier to read — it's easier to optimize. Visual structure reveals bottlenecks:
Formatted WHERE/JOIN clauses make it obvious which columns are filtered, helping you plan indexes.
Correlated subqueries in SELECT lists stand out clearly as nested blocks in the column list.
Easier to trace the logical order: FROM -> JOIN -> WHERE -> GROUP BY.
Duplicate JOINs and unnecessary subqueries are easier to spot than in a single line string.
Yes. It supports MySQL, PostgreSQL, T-SQL (SQL Server), PL/SQL (Oracle), SQLite, and ANSI SQL. Dialect-specific syntax like `TOP`, `LIMIT`, and backticks is handled.
No. Formatting changes whitespace and capitalization only. It never modifies logic, structure, or values. The query remains semantically identical.
Yes. It handles `CREATE PROCEDURE`, `BEGIN...END` blocks, `IF/WHILE` loops, and `DECLARE` statements.
VS Code needs extensions (like 'SQL Formatter'). Our tool works instantly in the browser without setup. Great for quick tasks.
It removes whitespace to create a compact single-line string, useful for embedding in code variables, config files, or URLs.
Yes. It's optimized for performance and handles large queries with deep nesting and many JOINs.
It finds structural issues, but true validation depends on your specific database schema. Use `EXPLAIN` in your DB for full validation.
Yes. Use Ctrl+Enter (Cmd+Enter on Mac) in the editor.
Yes. Click the download button to save as a `.sql` file.
Style preference. Uppercase is the standard professional convention for readability, which our tool uses by default.
Paste your query above — no matter how long, nested, or messy — and get formatted SQL back in one click.