<form method="POST">
    <h3>Editing: ThrottleRequests.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Routing\Middleware;

use Closure;
use Illuminate\Cache\RateLimiter;
use Illuminate\Cache\RateLimiting\Unlimited;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Http\Exceptions\ThrottleRequestsException;
use Illuminate\Support\Arr;
use Illuminate\Support\InteractsWithTime;
use Illuminate\Support\Str;
use RuntimeException;
use Symfony\Component\HttpFoundation\Response;

class ThrottleRequests
{
    use InteractsWithTime;

    /**
     * The rate limiter instance.
     *
     * @var \Illuminate\Cache\RateLimiter
     */
    protected $limiter;

    /**
     * Create a new request throttler.
     *
     * @param  \Illuminate\Cache\RateLimiter  $limiter
     * @return void
     */
    public function __construct(RateLimiter $limiter)
    {
        $this-&gt;limiter = $limiter;
    }

    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  int|string  $maxAttempts
     * @param  float|int  $decayMinutes
     * @param  string  $prefix
     * @return \Symfony\Component\HttpFoundation\Response
     *
     * @throws \Illuminate\Http\Exceptions\ThrottleRequestsException
     */
    public function handle($request, Closure $next, $maxAttempts = 60, $decayMinutes = 1, $prefix = '')
    {
        if (is_string($maxAttempts)
            &amp;&amp; func_num_args() === 3
            &amp;&amp; ! is_null($limiter = $this-&gt;limiter-&gt;limiter($maxAttempts))) {
            return $this-&gt;handleRequestUsingNamedLimiter($request, $next, $maxAttempts, $limiter);
        }

        return $this-&gt;handleRequest(
            $request,
            $next,
            [
                (object) [
                    'key' =&gt; $prefix.$this-&gt;resolveRequestSignature($request),
                    'maxAttempts' =&gt; $this-&gt;resolveMaxAttempts($request, $maxAttempts),
                    'decayMinutes' =&gt; $decayMinutes,
                    'responseCallback' =&gt; null,
                ],
            ]
        );
    }

    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  string  $limiterName
     * @param  \Closure  $limiter
     * @return \Symfony\Component\HttpFoundation\Response
     *
     * @throws \Illuminate\Http\Exceptions\ThrottleRequestsException
     */
    protected function handleRequestUsingNamedLimiter($request, Closure $next, $limiterName, Closure $limiter)
    {
        $limiterResponse = call_user_func($limiter, $request);

        if ($limiterResponse instanceof Response) {
            return $limiterResponse;
        } elseif ($limiterResponse instanceof Unlimited) {
            return $next($request);
        }

        return $this-&gt;handleRequest(
            $request,
            $next,
            collect(Arr::wrap($limiterResponse))-&gt;map(function ($limit) use ($limiterName) {
                return (object) [
                    'key' =&gt; md5($limiterName.$limit-&gt;key),
                    'maxAttempts' =&gt; $limit-&gt;maxAttempts,
                    'decayMinutes' =&gt; $limit-&gt;decayMinutes,
                    'responseCallback' =&gt; $limit-&gt;responseCallback,
                ];
            })-&gt;all()
        );
    }

    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  array  $limits
     * @return \Symfony\Component\HttpFoundation\Response
     *
     * @throws \Illuminate\Http\Exceptions\ThrottleRequestsException
     */
    protected function handleRequest($request, Closure $next, array $limits)
    {
        foreach ($limits as $limit) {
            if ($this-&gt;limiter-&gt;tooManyAttempts($limit-&gt;key, $limit-&gt;maxAttempts)) {
                throw $this-&gt;buildException($request, $limit-&gt;key, $limit-&gt;maxAttempts, $limit-&gt;responseCallback);
            }

            $this-&gt;limiter-&gt;hit($limit-&gt;key, $limit-&gt;decayMinutes * 60);
        }

        $response = $next($request);

        foreach ($limits as $limit) {
            $response = $this-&gt;addHeaders(
                $response,
                $limit-&gt;maxAttempts,
                $this-&gt;calculateRemainingAttempts($limit-&gt;key, $limit-&gt;maxAttempts)
            );
        }

        return $response;
    }

    /**
     * Resolve the number of attempts if the user is authenticated or not.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int|string  $maxAttempts
     * @return int
     */
    protected function resolveMaxAttempts($request, $maxAttempts)
    {
        if (Str::contains($maxAttempts, '|')) {
            $maxAttempts = explode('|', $maxAttempts, 2)[$request-&gt;user() ? 1 : 0];
        }

        if (! is_numeric($maxAttempts) &amp;&amp; $request-&gt;user()) {
            $maxAttempts = $request-&gt;user()-&gt;{$maxAttempts};
        }

        return (int) $maxAttempts;
    }

    /**
     * Resolve request signature.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return string
     *
     * @throws \RuntimeException
     */
    protected function resolveRequestSignature($request)
    {
        if ($user = $request-&gt;user()) {
            return sha1($user-&gt;getAuthIdentifier());
        } elseif ($route = $request-&gt;route()) {
            return sha1($route-&gt;getDomain().'|'.$request-&gt;ip());
        }

        throw new RuntimeException('Unable to generate the request signature. Route unavailable.');
    }

    /**
     * Create a 'too many attempts' exception.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  string  $key
     * @param  int  $maxAttempts
     * @param  callable|null  $responseCallback
     * @return \Illuminate\Http\Exceptions\ThrottleRequestsException
     */
    protected function buildException($request, $key, $maxAttempts, $responseCallback = null)
    {
        $retryAfter = $this-&gt;getTimeUntilNextRetry($key);

        $headers = $this-&gt;getHeaders(
            $maxAttempts,
            $this-&gt;calculateRemainingAttempts($key, $maxAttempts, $retryAfter),
            $retryAfter
        );

        return is_callable($responseCallback)
                    ? new HttpResponseException($responseCallback($request, $headers))
                    : new ThrottleRequestsException('Too Many Attempts.', null, $headers);
    }

    /**
     * Get the number of seconds until the next retry.
     *
     * @param  string  $key
     * @return int
     */
    protected function getTimeUntilNextRetry($key)
    {
        return $this-&gt;limiter-&gt;availableIn($key);
    }

    /**
     * Add the limit header information to the given response.
     *
     * @param  \Symfony\Component\HttpFoundation\Response  $response
     * @param  int  $maxAttempts
     * @param  int  $remainingAttempts
     * @param  int|null  $retryAfter
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function addHeaders(Response $response, $maxAttempts, $remainingAttempts, $retryAfter = null)
    {
        $response-&gt;headers-&gt;add(
            $this-&gt;getHeaders($maxAttempts, $remainingAttempts, $retryAfter, $response)
        );

        return $response;
    }

    /**
     * Get the limit headers information.
     *
     * @param  int  $maxAttempts
     * @param  int  $remainingAttempts
     * @param  int|null  $retryAfter
     * @param  \Symfony\Component\HttpFoundation\Response|null  $response
     * @return array
     */
    protected function getHeaders($maxAttempts,
                                  $remainingAttempts,
                                  $retryAfter = null,
                                  ?Response $response = null)
    {
        if ($response &amp;&amp;
            ! is_null($response-&gt;headers-&gt;get('X-RateLimit-Remaining')) &amp;&amp;
            (int) $response-&gt;headers-&gt;get('X-RateLimit-Remaining') &lt;= (int) $remainingAttempts) {
            return [];
        }

        $headers = [
            'X-RateLimit-Limit' =&gt; $maxAttempts,
            'X-RateLimit-Remaining' =&gt; $remainingAttempts,
        ];

        if (! is_null($retryAfter)) {
            $headers['Retry-After'] = $retryAfter;
            $headers['X-RateLimit-Reset'] = $this-&gt;availableAt($retryAfter);
        }

        return $headers;
    }

    /**
     * Calculate the number of remaining attempts.
     *
     * @param  string  $key
     * @param  int  $maxAttempts
     * @param  int|null  $retryAfter
     * @return int
     */
    protected function calculateRemainingAttempts($key, $maxAttempts, $retryAfter = null)
    {
        return is_null($retryAfter) ? $this-&gt;limiter-&gt;retriesLeft($key, $maxAttempts) : 0;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>