Cómo crear una API REST profesional con Laravel en 2026

Laravel sigue siendo el framework PHP más popular para desarrollo backend, y por buenas razones. En esta guía te muestro cómo construir una API REST profesional desde cero, con las prácticas que uso en proyectos reales en RHINO.

1. Estructura del proyecto

Lo primero es tener una buena estructura. Laravel nos da una base sólida, pero para APIs profesionales necesitamos organizarnos mejor:

app/
├── Http/
│   ├── Controllers/Api/V1/
│   ├── Requests/
│   ├── Resources/
│   └── Middleware/
├── Models/
├── Services/
├── Repositories/
└── Exceptions/

La clave es separar responsabilidades: los controllers manejan HTTP, los services la lógica de negocio, y los repositories el acceso a datos. Esto hace tu código testeable y mantenible.

2. Autenticación con Laravel Sanctum

Para APIs, Laravel Sanctum es la opción recomendada. Es liviano, seguro y fácil de implementar. Soporta tanto tokens API como autenticación de SPA con cookies.

// Instalación
composer require laravel/sanctum
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
php artisan migrate

// En el modelo User
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
}

// Controller de autenticación
public function login(LoginRequest $request)
{
    $user = User::where('email', $request->email)->first();

    if (!$user || !Hash::check($request->password, $user->password)) {
        throw ValidationException::withMessages([
            'email' => ['Las credenciales son incorrectas.'],
        ]);
    }

    $token = $user->createToken('api-token')->plainTextToken;

    return response()->json([
        'user' => new UserResource($user),
        'token' => $token,
    ]);
}

3. Validación robusta con Form Requests

Nunca valides directamente en el controller. Usá Form Requests dedicados para mantener el código limpio:

// php artisan make:request StoreProductRequest

class StoreProductRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'price' => 'required|numeric|min:0',
            'description' => 'nullable|string|max:1000',
            'category_id' => 'required|exists:categories,id',
            'stock' => 'required|integer|min:0',
        ];
    }

    public function messages(): array
    {
        return [
            'name.required' => 'El nombre del producto es obligatorio.',
            'price.min' => 'El precio no puede ser negativo.',
        ];
    }
}

4. API Resources para respuestas consistentes

Los API Resources te permiten transformar tus modelos en JSON de forma consistente y controlada:

// php artisan make:resource ProductResource

class ProductResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'slug' => $this->slug,
            'price' => [
                'amount' => $this->price,
                'formatted' => '$' . number_format($this->price, 2),
            ],
            'category' => new CategoryResource($this->whenLoaded('category')),
            'in_stock' => $this->stock > 0,
            'created_at' => $this->created_at->toISOString(),
        ];
    }
}

5. Versionado de API

Siempre versioná tu API desde el día uno. Es mucho más fácil mantener versiones antiguas que romper clientes existentes:

// routes/api.php
Route::prefix('v1')->group(function () {
    Route::apiResource('products', Api\V1\ProductController::class);
    Route::apiResource('categories', Api\V1\CategoryController::class);
});

Route::prefix('v2')->group(function () {
    Route::apiResource('products', Api\V2\ProductController::class);
});

6. Manejo de errores centralizado

Un buen manejo de errores diferencia una API amateur de una profesional:

// app/Exceptions/Handler.php
public function render($request, Throwable $e)
{
    if ($request->expectsJson()) {
        if ($e instanceof ModelNotFoundException) {
            return response()->json([
                'error' => 'Recurso no encontrado',
                'message' => 'El elemento solicitado no existe.'
            ], 404);
        }

        if ($e instanceof AuthenticationException) {
            return response()->json([
                'error' => 'No autenticado',
                'message' => 'Necesitás iniciar sesión.'
            ], 401);
        }
    }

    return parent::render($request, $e);
}

7. Mejores prácticas

• Usá siempre HTTPS en producción
• Rate limiting: Laravel incluye throttle middleware por defecto
• Paginación: nunca devuelvas colecciones enteras, usá ->paginate()
• Cache: cacheá respuestas frecuentes con Redis
• Logs: registrá errores y acciones importantes
• Testing: escribí tests para cada endpoint
• Documentación: usá Swagger/OpenAPI o Scribe

Conclusión

Laravel te da todas las herramientas para construir APIs REST de nivel profesional. La clave está en seguir los patrones correctos desde el inicio: separar responsabilidades, validar todo, usar Resources, versionar y manejar errores correctamente. Con esta base, tu API va a ser mantenible, segura y escalable.

Si necesitás ayuda para construir la API de tu proyecto, contactame y trabajamos juntos.