Rate limiting aanpassen

Hoe de `RateLimiter`-facade werkt

De rate limiting van Laravel bestaat uit de klasse Illuminate\Cache\RateLimiting\Limit en de RateLimiter-facade. Intern worden tellers opgeslagen in een cachedriver (standaard file of Redis) om het aantal requests te volgen. De throttle-middleware voert voor een binnenkomend request de closure uit die je met RateLimiter::for() hebt gedefinieerd, en geeft 429 Too Many Requests terug wanneer de limiet is bereikt.

Custom limiters definiëren in de `AppServiceProvider`

De rate-limitingconfiguratie doe je in de boot()-methode van App\Providers\AppServiceProvider.

<?php

namespace App\Providers;

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        RateLimiter::for('api', function (Request $request) {
            return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
        });
    }
}

Het eerste argument van RateLimiter::for() is de naam van de limiter, die je gebruikt om ernaar te verwijzen vanuit de throttle-middleware. De closure in het tweede argument moet een Illuminate\Cache\RateLimiting\Limit-instantie teruggeven.

Rate limits per gebruiker, IP-adres en plan

Verschillende limieten voor ingelogde gebruikers en gasten

RateLimiter::for('uploads', function (Request $request) {
    return $request->user()
        ? Limit::perHour(100)->by($request->user()->id)
        : Limit::perHour(10)->by($request->ip());
});

Limieten op basis van het plan van de gebruiker

RateLimiter::for('api', function (Request $request) {
    $user = $request->user();

    if (! $user) {
        return Limit::perMinute(30)->by($request->ip());
    }

    return match ($user->plan) {
        'enterprise' => Limit::none(),
        'pro'        => Limit::perMinute(500)->by($user->id),
        default      => Limit::perMinute(60)->by($user->id),
    };
});

Een globale limiet op basis van het IP-adres

Throttling per IP-adres, onafhankelijk van een specifiek endpoint.

RateLimiter::for('global', function (Request $request) {
    return Limit::perMinute(1000)->by($request->ip());
});

Meerdere limieten combineren

Geef je een array terug, dan worden alle limieten geëvalueerd. Zodra er één wordt bereikt, volgt een 429.

RateLimiter::for('login', function (Request $request) {
    return [
        Limit::perMinute(10)->by($request->ip()),
        Limit::perMinute(5)->by($request->input('email')),
    ];
});

Als je meerdere limieten met dezelfde by-waarde definieert, voeg dan een prefix toe zodat de sleutels niet botsen.

RateLimiter::for('uploads', function (Request $request) {
    return [
        Limit::perMinute(10)->by('minute:' . $request->user()->id),
        Limit::perDay(1000)->by('day:' . $request->user()->id),
    ];
});

De `throttle`-middleware en een custom limiternaam opgeven

Geef de gedefinieerde limiternaam door aan de throttle-middleware.

use Illuminate\Support\Facades\Route;

Route::middleware(['throttle:api'])->group(function () {
    Route::get('/user', function () { /* ... */ });
    Route::post('/posts', function () { /* ... */ });
});

Registratie in `bootstrap/app.php`

Sinds Laravel 11 beheer je middleware in bootstrap/app.php.

use Illuminate\Foundation\Application;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__ . '/../routes/web.php',
        api: __DIR__ . '/../routes/api.php',
        apiPrefix: 'api',
    )
    ->withMiddleware(function (\Illuminate\Foundation\Configuration\Middleware $middleware): void {
        $middleware->throttleApi('api');
    })
    ->create();

Toepassingsvoorbeeld op API-routes

Definieer de limiters

Definieer meerdere limiters in de AppServiceProvider.

public function boot(): void
{
    // Algemene API-toegang
    RateLimiter::for('api', function (Request $request) {
        return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
    });

    // Bestandsuploads
    RateLimiter::for('uploads', function (Request $request) {
        return $request->user()?->isPro()
            ? Limit::perHour(500)->by($request->user()->id)
            : Limit::perHour(50)->by($request->user()?->id ?: $request->ip());
    });

    // Inlogpogingen
    RateLimiter::for('login', function (Request $request) {
        return [
            Limit::perMinute(10)->by($request->ip()),
            Limit::perMinute(5)->by($request->input('email')),
        ];
    });
}

Pas de middleware toe op de routes

// routes/api.php
use Illuminate\Support\Facades\Route;

Route::middleware(['auth:sanctum', 'throttle:api'])->group(function () {
    Route::get('/user', [\App\Http\Controllers\UserController::class, 'show']);
    Route::get('/posts', [\App\Http\Controllers\PostController::class, 'index']);
});

Route::middleware(['auth:sanctum', 'throttle:uploads'])->group(function () {
    Route::post('/uploads', [\App\Http\Controllers\UploadController::class, 'store']);
});

Route::middleware(['throttle:login'])->group(function () {
    Route::post('/login', [\App\Http\Controllers\AuthController::class, 'login']);
});

Hoe de responseheaders (`X-RateLimit-*`) werken

De throttle-middleware voegt de limietinformatie automatisch toe aan de responseheaders.

Header	Toelichting
`X-RateLimit-Limit`	Het toegestane aantal requests
`X-RateLimit-Remaining`	Het resterende aantal requests
`Retry-After`	Het aantal seconden tot het volgende request mogelijk is (alleen bij 429)
`X-RateLimit-Reset`	De UNIX-timestamp waarop de limiet wordt gereset

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0
Retry-After: 45
X-RateLimit-Reset: 1717000000
Content-Type: application/json

{
    "message": "Too Many Requests."
}

Een custom response teruggeven

RateLimiter::for('api', function (Request $request) {
    return Limit::perMinute(60)
        ->by($request->user()?->id ?: $request->ip())
        ->response(function (Request $request, array $headers) {
            return response()->json([
                'message' => 'Je hebt de requestlimiet overschreden. Probeer het over een tijdje opnieuw.',
                'retry_after' => $headers['Retry-After'],
            ], 429, $headers);
        });
});

Handmatig controleren met `RateLimiter::attempt()`

Wil je zonder de throttle-middleware op een willekeurig moment in je code een rate limit controleren, dan gebruik je RateLimiter::attempt().

use Illuminate\Support\Facades\RateLimiter;

class SmsController extends Controller
{
    public function send(Request $request): \Illuminate\Http\JsonResponse
    {
        $key = 'sms:' . $request->user()->id;

        $executed = RateLimiter::attempt(
            key: $key,
            maxAttempts: 5,
            callback: function () use ($request) {
                app(SmsService::class)->send(
                    $request->user()->phone,
                    $request->input('message')
                );
            },
            decaySeconds: 3600,  // 1 uur
        );

        if (! $executed) {
            $seconds = RateLimiter::availableIn($key);

            return response()->json([
                'message' => "Je hebt de sms-limiet overschreden. Probeer het over {$seconds} seconden opnieuw.",
            ], 429);
        }

        return response()->json(['message' => 'De sms is verstuurd.']);
    }
}

Het aantal pogingen controleren en resetten

// Het huidige aantal pogingen opvragen
$hits = RateLimiter::attempts($key);

// Aantal seconden tot de volgende reset
$seconds = RateLimiter::availableIn($key);

// Controleren of de limiet is bereikt
$tooMany = RateLimiter::tooManyAttempts($key, $maxAttempts = 5);

// De teller handmatig resetten (bijvoorbeeld na uitloggen)
RateLimiter::clear($key);

Voorbeeld van loginthrottling

public function login(Request $request): mixed
{
    $key = 'login:' . $request->input('email');

    if (RateLimiter::tooManyAttempts($key, 5)) {
        $seconds = RateLimiter::availableIn($key);

        throw ValidationException::withMessages([
            'email' => "Te veel inlogpogingen. Probeer het over {$seconds} seconden opnieuw.",
        ]);
    }

    if (! Auth::attempt($request->only('email', 'password'))) {
        RateLimiter::hit($key, 300);  // Tellen gedurende 5 minuten

        throw ValidationException::withMessages([
            'email' => 'Het e-mailadres of wachtwoord is onjuist.',
        ]);
    }

    RateLimiter::clear($key);

    return redirect()->intended('/dashboard');
}

Responsegebaseerde rate limiting

Wil je alleen bepaalde responses meetellen, dan gebruik je after(). Een voorbeeld dat alleen 404-responses telt om resource-enumeratieaanvallen te voorkomen:

use Symfony\Component\HttpFoundation\Response;

RateLimiter::for('resource-lookup', function (Request $request) {
    return Limit::perMinute(10)
        ->by($request->user()?->id ?: $request->ip())
        ->after(function (Response $response) {
            return $response->getStatusCode() === 404;
        });
});

Rate limiting met Redis

Zodra je de standaard-cachedriver naar Redis wijzigt, gebruikt ook de throttle-middleware automatisch Redis.

De Redis-driver configureren

// config/cache.php
'default' => env('CACHE_DRIVER', 'redis'),

# .env
CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PORT=6379

`throttleWithRedis` gebruiken

Om de voor Redis geoptimaliseerde throttlingmiddleware te gebruiken, roep je throttleWithRedis() aan in bootstrap/app.php.

use Illuminate\Foundation\Application;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__ . '/../routes/web.php',
        api: __DIR__ . '/../routes/api.php',
        apiPrefix: 'api',
    )
    ->withMiddleware(function (\Illuminate\Foundation\Configuration\Middleware $middleware): void {
        $middleware->throttleWithRedis();
    })
    ->create();

Hierdoor wordt de throttle-middleware gemapt op de klasse ThrottleRequestsWithRedis, die met de atomische operaties van Redis nauwkeurig telt.

Zorg dat Redis altijd beschikbaar is wanneer je throttleWithRedis() gebruikt. Als de verbinding met Redis mislukt, kunnen alle requests worden geweigerd.

De voordelen van Redis

Ondersteuning voor horizontaal schalen — tellers kunnen worden gedeeld tussen meerdere serverinstanties
Hoge nauwkeurigheid — atomische operaties voorkomen race conditions
TTL-beheer — tellers worden automatisch verwijderd via de native verloopfunctionaliteit van Redis

Gerelateerde pagina’s

Cache

Bekijk de configuratie en het gebruik van de cachedrivers van Laravel, inclusief Redis.

AI-ontwikkeling

Design patterns

Package-ontwikkeling

Applicatiestructuur

Nieuwe functies in Laravel 13

Eloquent in detail

Validatie-uitbreidingen

Authenticatie uitbreiden

Beveiliging

Queues

Testen

Hoe de `RateLimiter`-facade werkt

Custom limiters definiëren in de `AppServiceProvider`

Rate limits per gebruiker, IP-adres en plan

Verschillende limieten voor ingelogde gebruikers en gasten

Limieten op basis van het plan van de gebruiker

Een globale limiet op basis van het IP-adres

Meerdere limieten combineren

De `throttle`-middleware en een custom limiternaam opgeven

Registratie in `bootstrap/app.php`

Toepassingsvoorbeeld op API-routes

Hoe de responseheaders (`X-RateLimit-*`) werken

Een custom response teruggeven

Handmatig controleren met `RateLimiter::attempt()`

Het aantal pogingen controleren en resetten

Voorbeeld van loginthrottling

Responsegebaseerde rate limiting

Rate limiting met Redis

De Redis-driver configureren

`throttleWithRedis` gebruiken

De voordelen van Redis

Gerelateerde pagina’s

Cache

​Hoe de RateLimiter-facade werkt

​Custom limiters definiëren in de AppServiceProvider

​Rate limits per gebruiker, IP-adres en plan

​Verschillende limieten voor ingelogde gebruikers en gasten

​Limieten op basis van het plan van de gebruiker

​Een globale limiet op basis van het IP-adres

​Meerdere limieten combineren

​De throttle-middleware en een custom limiternaam opgeven

​Registratie in bootstrap/app.php

​Toepassingsvoorbeeld op API-routes

​Hoe de responseheaders (X-RateLimit-*) werken

​Een custom response teruggeven

​Handmatig controleren met RateLimiter::attempt()

​Het aantal pogingen controleren en resetten

​Voorbeeld van loginthrottling

​Responsegebaseerde rate limiting

​Rate limiting met Redis

​De Redis-driver configureren

​throttleWithRedis gebruiken

​De voordelen van Redis

​Gerelateerde pagina’s

Cache

Hoe de `RateLimiter`-facade werkt

Custom limiters definiëren in de `AppServiceProvider`

Rate limits per gebruiker, IP-adres en plan

Verschillende limieten voor ingelogde gebruikers en gasten

Limieten op basis van het plan van de gebruiker

Een globale limiet op basis van het IP-adres

Meerdere limieten combineren

De `throttle`-middleware en een custom limiternaam opgeven

Registratie in `bootstrap/app.php`

Toepassingsvoorbeeld op API-routes

Hoe de responseheaders (`X-RateLimit-*`) werken

Een custom response teruggeven

Handmatig controleren met `RateLimiter::attempt()`

Het aantal pogingen controleren en resetten

Voorbeeld van loginthrottling

Responsegebaseerde rate limiting

Rate limiting met Redis

De Redis-driver configureren

`throttleWithRedis` gebruiken

De voordelen van Redis

Gerelateerde pagina’s