> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Rate limiting aanpassen

> Een diepgaande blik op de RateLimiter-facade van Laravel: van custom rate limits per gebruiker, plan en IP-adres tot een hoogbeschikbare configuratie met Redis.

## 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 theme={null}
<?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

```php theme={null}
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

```php theme={null}
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.

```php theme={null}
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`.

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

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

```php theme={null}
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.

```php theme={null}
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`.

```php theme={null}
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

<Steps>
  <Step title="Definieer de limiters">
    Definieer meerdere limiters in de `AppServiceProvider`.

    ```php theme={null}
    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')),
            ];
        });
    }
    ```
  </Step>

  <Step title="Pas de middleware toe op de routes">
    ```php theme={null}
    // 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']);
    });
    ```
  </Step>
</Steps>

## 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 theme={null}
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

```php theme={null}
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()`.

```php theme={null}
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

```php theme={null}
// 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

```php theme={null}
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:

```php theme={null}
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

```php theme={null}
// config/cache.php
'default' => env('CACHE_DRIVER', 'redis'),
```

```ini theme={null}
# .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`.

```php theme={null}
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.

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

### 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

<Card title="Cache" icon="database" href="/nl/cache">
  Bekijk de configuratie en het gebruik van de cachedrivers van Laravel, inclusief Redis.
</Card>


## Related topics

- [Laravel Agent Detector — pakket voor het detecteren van AI-agents](/nl/blog/agent-detector-introduction.md)
- [Upgraden van Laravel 10 naar 11](/nl/blog/upgrade-10-to-11.md)
- [Laravel Fortify en de starter kits](/nl/advanced/fortify.md)
- [Laravel-updates van maart 2026](/nl/blog/changelog/202603.md)
- [InteractsWithTime-trait](/nl/advanced/interacts-with-time.md)