Send header in get request using Laravel Http Client
Stefan Bogdanescu
Founder & Senior Architect · 2026-06-29
# Sending Custom Headers in GET Requests with the Laravel HTTP Client
As developers working with APIs, one of the most common tasks is interacting with external services, which almost always requires authentication or specific content negotiation via HTTP headers. When using Laravel's powerful `Http` facade (the HTTP Client), passing these necessary headers to a GET request can seem straightforward, but understanding the correct method is crucial for robust API interaction.
If you are trying to send custom headers during an `Http::get()` request, you need to utilize the methods provided by the client correctly. Let's break down the proper way to handle this, moving beyond manual string concatenation to use Laravelâs built-in capabilities.
## Understanding HTTP Headers in API Communication
HTTP headers are metadata sent along with the actual request or response. They tell the server how to process the request (e.g., authentication tokens, content type, caching instructions). For secure and functional API calls, headers like `Authorization` and `Content-Type` are essential.
When using the Laravel HTTP Client, we abstract this complexity into clean methods that handle the necessary HTTP framing for you. Trying to manually construct raw header strings can often lead to errors or security vulnerabilities if not handled precisely.
## The Correct Way: Using `withHeaders()`
The most idiomatic and recommended way to attach headers to an HTTP request in Laravel is by using the `withHeaders()` method. This method accepts an associative array where the keys are the header names and the values are the corresponding header values.
Here is a practical example demonstrating how to secure a request with an Authorization token:
```php
use Illuminate\Support\Facades\Http;
// Assume $accessToken holds your valid token from Zoho
$accessToken = 'your_actual_zoho_token_here';
try {
$response = Http::withHeaders([
'Authorization' => "Zoho-oauthtoken {$accessToken}",
'Accept' => 'application/json', // Specifying what format we expect back
])->get('https://subscriptions.zoho.com/api/v1/plans');
// Handle the response
$data = $response->json();
return $data;
} catch (\Illuminate\Http\Client\RequestException $e) {
// Handle API errors gracefully
return "Error fetching data: " . $e->getMessage();
}
```
### Why this approach is superior:
1. **Readability:** The code clearly defines which headers are being sent and what their values are.
2. **Safety:** It prevents common string concatenation errors that can occur when manually building header strings, making your code more robust.
3. **Laravel Integration:** This leverages the core functionality of the Laravel HTTP Client, aligning perfectly with best practices promoted by frameworks like those discussed on **laravelcompany.com**.
## Handling Multiple or Dynamic Headers
If you need to manage many dynamic headers, or if you are dealing with complex scenarios where headers depend on runtime logic, passing them in a structured array is far more efficient than building individual query parameters or manually concatenating strings.
For instance, if you needed to send both an `Authorization` header and a custom `X-Client-ID`, you would simply combine them into the same array:
```php
$dynamicHeaders = [
'Authorization' => "Bearer " . $accessToken,
'X-Client-ID' => 'my-app-client-123',
];
$response = Http::withHeaders($dynamicHeaders)->get('https://api.example.com/data');
```
This pattern ensures that all necessary metadata is cleanly attached to the request object before it is sent, which is a hallmark of clean API interaction.
## Conclusion
Sending headers in HTTP requests with the Laravel HTTP Client should always be done through structured methods like `withHeaders()`. By adopting this approach, you ensure your code is readable, maintainable, and resilient against common errors. Whether you are integrating third-party services or building complex internal APIs, mastering these fundamental request mechanics is key to writing high-quality, professional Laravel applications. Always strive for clean abstractions when working with HTTP interactions, just as the principles of robust design guide development at **laravelcompany.com**.