Laravel get unamed "GET" parameter id from URL
Stefan Bogdanescu
Founder & Senior Architect · 2026-06-29
# Laravel: How to Get Unnamed IDs from URL Path Segments
As a senior developer working with the Laravel ecosystem, dealing with routing and request parameters is fundamental. It's incredibly common to encounter situations where you need to extract dynamic values directly from the URL, but the method you are using isn't yielding the expected results.
The issue you are facing stems from a common confusion between two distinct ways of passing data in a URL: **Route Parameters** (part of the path structure) and **Query String Parameters** (standard GET parameters). Understanding this difference is the key to solving your problem efficiently in Laravel.
This post will walk you through the correct, idiomatic Laravel ways to extract those dynamic IDs from the URL.
---
## Understanding URL Structure: Path vs. Query Strings
Let's first clarify the structure you are trying to parse: `http://localhost:8000/new-user/7`.
In this URL structure, the segment `/new-user/7` is not a standard query string parameter (which looks like `?id=7`). Instead, it is a **Route Parameter**. This parameter is explicitly defined within your route definition to capture dynamic parts of the URL path.
When you use Laravel's routing system, you define these segments as placeholders. When a request hits that URL, Laravel automatically maps the segment values to variables accessible in your controller.
### Why Your Attempts Failed
Your attempts failed because they were focused on standard query parameters or hidden form data:
1. **`$request->route('company_id')`:** This only works if you explicitly named a route parameter `company_id`. If the URL is `/new-user/{id}`, and you don't name the segment, this method won't find it unless configured correctly via the route file.
2. **Hidden Form Fields (`Input::get()`, `$_GET`):** These methods only capture data sent via the HTTP request body (POST/form submissions) or the URL query string (`?key=value`). They cannot read the structure of the URL path itself.
## The Correct Solution: Using Route Parameters
To correctly access dynamic segments from the URL, you must define them in your route file and then retrieve them using the `Route` facade or the `Request` object in your controller.
### Step 1: Define the Route with a Parameter
In your `routes/web.php` file, define your route to include a placeholder for that dynamic ID:
```php
// routes/web.php
use App\Http\Controllers\UserController;
// The {id} here is the named parameter we will capture from the URL path.
Route::get('/new-user/{id}', [UserController::class, 'showNewUser']);
```
### Step 2: Retrieve the Parameter in the Controller
Now, inside your controller method, you can retrieve this value using the `Route` helper or by type-hinting the parameter directly into the function signature. Type-hinting is the most recommended and safest practice in modern Laravel development.
**Method A: Using Route Model Binding (Recommended)**
If you are using Eloquent relationships, Laravel offers powerful Route Model Binding to automatically fetch the model based on the URL segment:
```php
// app/Http/Controllers/UserController.php
use App\Models\User;
use Illuminate\Http\Request;
class UserController extends Controller
{
public function showNewUser(int $id) // Laravel automatically injects '7' from the URL here
{
// $id is now directly available as an integer
$user = User::findOrFail($id);
return view('new_user', compact('user'));
}
}
```
**Method B: Using the Request Object (For raw access)**
If you need to retrieve the parameter explicitly using the request object, you can use `route()` or `segment()` methods. For simple path parameters, accessing the route parameters is straightforward:
```php
// app/Http/Controllers/UserController.php
use Illuminate\Http\Request;
class UserController extends Controller
{
public function showNewUser(Request $request)
{
// Retrieve the 'id' segment from the current route definition
$userId = $request->route('id');
// Or, if you defined the parameter simply as {id} without a specific name:
// $userId = $request->segment(2); // This gets the second segment in the path
return "Fetching user with ID: " . $userId;
}
}
```
## Conclusion
The confusion between URL paths and query strings is a common hurdle when starting with routing. Remember that **URL path segments** (like `/new-user/7`) are handled by Laravel's routing system, making them accessible via route parameters rather than standard `$_GET` variables or form inputs. By defining your routes correctly, you leverage Laravel's powerful request handling capabilities, ensuring cleaner, more robust, and more maintainable code, which is a core principle of building applications on the **laravelcompany.com** platform. Always prioritize using route parameters for navigating the application structure!