How to Get Raw SQL from Laravel Query Builder

By the end of this page, you will understand how Laravel's query builder builds SQL, how to get the SQL template using toSql(), how parameter bindings work, and how developers typically debug and inspect queries in real Laravel projects.

Laravel's query builder does not immediately run SQL when you start chaining methods like table(), where(), or orderBy(). Instead, it builds a query object step by step.

When you finally call methods like get(), first(), insert(), update(), or delete(), Laravel compiles that query object into SQL and sends it to the database.

To inspect the SQL before execution, Laravel provides:

• toSql() — returns the SQL string with placeholders such as ?
• getBindings() — returns the values that will be inserted into those placeholders

This matters because in real development you often need to:

• debug a query that is not returning expected results
• verify filters and joins
• optimize performance
• log generated SQL
• compare what Laravel builds against handwritten SQL

A key detail: the SQL returned by toSql() is usually a prepared statement template, not a fully interpolated final SQL string. That means values are often shown as ? placeholders instead of being inserted directly into the string.

Think of the query builder like filling out a restaurant order form.

• DB::table('users') chooses the menu section
• where(...) adds conditions to the order
• orderBy(...) adds sorting instructions
• toSql() shows the printed order ticket template
• getBindings() shows the actual values that will be attached to that ticket
• get() sends the order to the kitchen

So toSql() shows the structure of the query, while getBindings() shows the data that will be plugged into it.

Basic syntax

Use toSql() on the builder before executing it:

$sql = DB::table('users')->toSql();

echo $sql;

Output:

select * from `users`

Depending on your database driver, quoting may vary. For example, MySQL often uses backticks.

Important: do not call get() first

This will not work the way you expect:

DB::table('users')->get()->toSql();

Why? Because get() executes the query and returns a collection, not a query builder.

Query with bindings

$query = DB::table('users')->where(, );

 = ->();
 = ->();

();
();

Consider this example:

$query = DB::table('users')
    ->where('active', 1)
    ->orderBy('name');

dd($query->toSql(), $query->getBindings());

Step 1: DB::table('users')

Laravel creates a query builder for the users table.

Step 2: where('active', 1)

Laravel adds a filter condition.

At this point, the builder knows:

• the table is users
• there is a where clause on active
• the value 1 is stored as a binding

Step 3: orderBy('name')

Laravel adds sorting to the query definition.

Step 4:

Developers inspect raw SQL in Laravel for many practical reasons:

Debugging incorrect results

If a query returns too many or too few rows, checking the SQL helps confirm whether the conditions were built correctly.

Performance tuning

You may want to copy the SQL into your database client and run EXPLAIN to inspect indexes and query cost.

Logging slow queries

Applications often log generated SQL during development or when investigating production issues.

Verifying dynamic filters

If your app builds queries from request parameters, inspecting SQL helps confirm that optional filters are applied correctly.

Learning SQL through Laravel

Beginners often use toSql() to connect Laravel query builder syntax to the actual SQL being sent to the database.

In real Laravel projects, developers usually inspect queries using a few common patterns.

1. Inspect before execution

$query = DB::table('users')->where('role', 'admin');

dd($query->toSql(), $query->getBindings());

This is the simplest pattern when debugging one query.

2. Reuse the builder

$query = DB::table('users')->where('active', 1);

logger()->debug($query->toSql(), $query->getBindings());

$users = $query->get();

Store the builder in a variable so you can inspect it and then execute it.

3. Listen to all queries

Laravel can listen for every query executed during a request:

Calling toSql() after get()

Broken code:

DB::table('users')->get()->toSql();

Problem:

• get() returns a collection of results
• collections do not have the same query-builder methods

Fix:

DB::table('users')->toSql();

Expecting bound values inside toSql()

Broken expectation:

$query = DB::table('users')->where('id', 5);
echo $query->toSql();

You may expect:

select   `users`  `id`  

// Get SQL template
$sql = DB::table('users')->toSql();

// Get bindings
$bindings = DB::table('users')->where('id', 1)->getBindings();

// Debug both
$query = DB::table('users')->where('id', 1);
dd($query->toSql(), $query->getBindings());

// Execute after inspection
$query = DB::table('users')->where('active', 1);
$users = $query->get();

// Listen to all queries
DB::listen(function ($query) {
    logger($query->sql, $query->bindings);
});

Rules to remember

How do I print the SQL query in Laravel?

Use toSql() on the query builder:

echo DB::table('users')->toSql();

Why does Laravel show ? instead of actual values?

Laravel uses prepared statements. The SQL and the values are stored separately for safety and performance.

How do I see the values for the placeholders?

Use getBindings():

$query = DB::table('users')->where('id', 10);
dd($query->toSql(), $query->getBindings());

Can I use toSql() with Eloquent?

Yes.

User::where('active', 1)->();

• Laravel Eloquent — Eloquent builds SQL in a similar way and also supports toSql().
• Prepared statements — explains why values appear as ? placeholders instead of being inserted directly.
• Parameter binding — helps you understand how query values are stored separately from SQL.
• Laravel query logging — useful for inspecting executed queries across a request.
• Database debugging — broader techniques for troubleshooting query behavior and performance.
• SQL SELECT statements — the underlying SQL concept generated by the query builder.
• Laravel Collections — important because get() returns a collection, not a builder.