Laravel retrieving data from REST API

Laravel retrieving data from REST API

  1. Blog
  2. 15 November 2026
  3. 3 min read

Stefan Bogdanescu

Founder & Senior Architect

Integrating External REST APIs into Laravel Models and Controllers

Building a system that ingests data from an external REST API and persists it to your local database is a common architectural pattern. The core question isn't whether Laravel has a built-in mechanism for this—it does, via the Http facade—but rather where to place that logic so your application remains maintainable. You generally want to avoid bloating your Controllers with raw HTTP calls and JSON parsing. Instead, the most idiomatic approach in Laravel is to treat external APIs as if they were local resources or to leverage existing Model relationships.

The Service Layer Pattern for External Data

While you can place an Http request directly inside a Controller, this couples your route logic tightly to the specifics of the third-party API. If that API changes its endpoint structure or authentication method later, you risk breaking multiple controllers simultaneously. A better practice is to extract the HTTP interaction into a dedicated Service class.

Consider creating a service like ExternalDataService. This class handles the nuances of the external connection: setting headers, managing tokens, and parsing the response. Your Controller then remains responsible for high-level orchestration—validating user input and deciding which data points to fetch—but delegates the actual network call to the service.

// app/Services/ExternalDataService.php

namespace App\Services;

use Illuminate\Support\Facades\Http;

class ExternalDataService
{
    protected $baseUrl;
    protected $apiKey;

    public function __construct()
    {
        $this->baseUrl = config('services.external_api.base_url');
        $this->apiKey = config('services.external_api.key');
    }

    public function fetchResource($id)
    {
        $response = Http::withHeaders([
            'Authorization' => 'Bearer ' . $this->apiKey,
            'Accept' => 'application/json',
        ])->get("{$this->baseUrl}/items/{$id}");

        if ($response->failed()) {
            throw new \Exception('Failed to fetch data from external source.');
        }

        return $response->json();
    }
}

In this example, the controller simply requests the service method. This separation of concerns ensures that error handling related to the external API (like rate limiting or malformed responses) is centralized within the service layer.

Leveraging Laravel Models via HasApiResource

Laravel provides a specific trait designed exactly for this scenario: Illuminate\Database\Eloquent\Relations\HasApiResource. When you use this trait, your Eloquent model automatically gains methods to fetch related data from an external API as if it were a local relationship.

You define the mapping between your local model and the external resource in the model itself. Laravel then handles the HTTP request internally, allowing you to query the external data using standard Eloquent syntax.

// app/Models/Order.php

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasApiResource;

class Order extends Model
{
    use HasApiResource;

    protected $fillable = ['id', 'user_id', 'external_id'];

    /**
     * Define the API endpoint and mapping.
     */
    public function externalItem(): HasApiResource
    {
        return new HasApiResource([
            'url' => '/items/{item_id}',
            'mapping' => [
                'name' => 'external_name',
                'price' => 'cost',
            ],
            'headers' => ['Authorization' => 'Bearer {token}'],
        ]);
    }
}

With this setup, you can write queries like Order::with('externalItem')->get(), and Laravel will seamlessly fetch the data from the REST endpoint. This approach is particularly useful when the external data is read-only or when you want to keep your local models decoupled from the specific HTTP client implementation details.

Handling Data Transformation and Storage

Once the data arrives—whether via a Service class or HasApiResource—the final step is persisting it. You might choose to store the raw JSON payload alongside transformed fields for performance reasons. If you need to process large batches of data from an API, consider using Laravel's queue system with jobs that handle individual records asynchronously to avoid blocking the request cycle.

Be mindful of how you handle authentication tokens. Storing them in environment variables is standard, but ensure your Service or Model knows where to find them without hardcoding sensitive values. Always validate the external response structure before attempting to map fields; mismatched keys will result in silent failures if not explicitly handled.

If you are managing complex API integrations at scale or need specialized orchestration patterns beyond these examples, resources like https://laravelcompany.com can offer deeper insights into scaling Laravel applications with external dependencies.

Our network