laravel-honeypot

When adding a form to a public site, there's a risk that spam bots will try to submit it with fake values. Luckily, the majority of these bots are pretty dumb. You can thwart most of them by adding an invisible field to your form that should never contain a value when submitted. Such a field is called a honeypot. These spam bots will just fill all fields, including the honeypot.

When a submission comes in with a filled honeypot field, this package will discard that request. On top of that this package also checks how long it took to submit the form. This is done using a timestamp in another invisible field. If the form was submitted in a ridiculously short time, the anti spam will also be triggered.

After installing this package, all you need to do is to add the x-honeypot Blade component to your form.

<form method="POST">
    <x-honeypot />
    <input name="myField" type="text">
</form>

The package also supports manually passing the necessary values to your view layer, so you can easily add honeypot fields to your Inertia powered app.

Support us

We invest a lot of resources into creating best in class open source packages. You can support us by buying one of our paid products.

We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on our contact page. We publish all received postcards on our virtual postcard wall.

Video tutorial

In this video, which is part of the Mailcoach video course, you can see how the package can be installed and used.

Installation

You can install the package via composer:

composer require spatie/laravel-honeypot

Optionally, you can publish the config file of the package.

 php artisan vendor:publish --provider="Spatie\Honeypot\HoneypotServiceProvider" --tag="honeypot-config"

This is the content of the config file that will be published at config/honeypot.php:

…

Usage

First, you must add the x-honeypot Blade component to any form you wish to protect.

<form method="POST" action="{{ route('contactForm.submit') }}")>
    <x-honeypot />
    <input name="myField" type="text">
</form>

Alternatively, you can use the @honeypot Blade directive:

<form method="POST" action="{{ route('contactForm.submit') }}")>
    @honeypot
    <input name="myField" type="text">
</form>

Using either the Blade component or directive will add two fields: my_name and valid_from_timestamp (you can change the names in the config file).

Next, you must use the Spatie\Honeypot\ProtectAgainstSpam middleware in the route that handles the form submission. This middleware will intercept any request that submits a non empty value for the key named my_name. It will also intercept the request if it is submitted faster than the encrypted timestamp that the package generated in valid_from_timestamp.

use App\Http\Controllers\ContactFormSubmissionController;
use Spatie\Honeypot\ProtectAgainstSpam;

Route::post('contact', [ContactFormSubmissionController::class, 'create'])->middleware(ProtectAgainstSpam::class);

If you want to integrate the Spatie\Honeypot\ProtectAgainstSpam middleware with Laravel's built in authentication routes, wrap the Auth::routes(); declaration with the appropriate middleware group (make sure to add the @honeypot directive to the authentication forms).

use Spatie\Honeypot\ProtectAgainstSpam;

Route::middleware(ProtectAgainstSpam::class)->group(function() {
    Auth::routes();
});

If your app has a lot of forms handled by many different controllers, you could opt to register it as global middleware.

// inside app\Http\Kernel.php

protected $middleware = [
   // ...
   \Spatie\Honeypot\ProtectAgainstSpam::class,
];

Usage in Inertia

When using Inertia you must manually pass the values used in the honeypot fields. Here's an example:

// in a controller
public function create(\Spatie\Honeypot\Honeypot $honeypot) 
{
    return inertia('contactform.show', [
        'honeypot' => $honeypot,
    ]);
}

Your front-end will get an honeypot object with these keys: enabled, nameFieldName, validFromFieldName, encryptedValidFrom.

Here's an example how these values could be rendered using Vue:

And then in your Vue component, add these values to your form data:

props: ['honeypot'],

data() {
    return {
        form: this.$inertia.form({
            [this.honeypot.nameFieldName]: '',
            [this.honeypot.validFromFieldName]: this.honeypot.encryptedValidFrom,
        }),
    }
}

Usage with Jetstream (Vue/Inertia)

To make things work follow this steps:

1. Add \Spatie\Honeypot\ProtectAgainstSpam::class to bootstrap/app.php in ->withMiddleware block. For example:

        $middleware->web(append: [
            \App\Http\Middleware\HandleInertiaRequests::class,
            \Illuminate\Http\Middleware\AddLinkHeadersForPreloadedAssets::class,

            // will silenty reload Login page
            \Spatie\Honeypot\ProtectAgainstSpam::class,    // <- this
        ]);

or

        $middleware->web(append: [
            \App\Http\Middleware\HandleInertiaRequests::class,
            \Illuminate\Http\Middleware\AddLinkHeadersForPreloadedAssets::class,
        ]);

        // will show blank response page in iframe inside modal
        $middleware->append(\Spatie\Honeypot\ProtectAgainstSpam::class);

1. Add honeypot variable to share block of app/Http/Middleware/HandleInertiaRequests.php middleware. For example:

    public function share(Request $request): array
    {
        return array_merge(parent::share($request), [
            // read more here https://laravel.com/docs/11.x/authorization#authorization-and-inertia
            'honeypot' => new \Spatie\Honeypot\Honeypot(config('honeypot'))
        ]);
    }

1. Add honeypot elements to Pages you want. For example resourses/js/Pages/Auth/Login.vue like this:

Redefine props like this:

const props = defineProps({
    canResetPassword: Boolean,
    status: String,
    honeypot: Object,
});

Redefine form like this:

const form = useForm({
    email: '',
    password: '',
    remember: false,
    [props.honeypot.nameFieldName]: '',
    [props.honeypot.validFromFieldName]: props.honeypot.encryptedValidFrom,
});

And add html to template, like this:

In Register.vue changes will be:

const props = defineProps({
    honeypot: Object,
});

const form = useForm({
    name: '',
    email: '',
    password: '',
    password_confirmation: '',
    terms: false,
    [props.honeypot.nameFieldName]: '',
    [props.honeypot.validFromFieldName]: props.honeypot.encryptedValidFrom,
});

and

That's all.

Usage in Livewire

You can use this package to prevent spam submission to forms powered by Livewire.

First, add the UsesSpamProtection trait to your Livewire component:

use Spatie\Honeypot\Http\Livewire\Concerns\UsesSpamProtection;

class YourComponent extends Component
{
    use UsesSpamProtection;

Next, declare a HoneypotData property and call protectAgainstSpam() in the method that handles form submissions:

use Spatie\Honeypot\Http\Livewire\Concerns\HoneypotData;

class YourComponent extends Component
{
    // ...
    
    public HoneypotData $extraFields;
    
    public function mount()
    {
        $this->extraFields = new HoneypotData();
    }
 
   
    public function submit(): void 
    {
        $this->protectAgainstSpam(); // if is spam, will abort the request
    
        User::create($request->all());
    }
}

Finally, use the x-honeypot in your Livewire Blade component:

<form method="POST" action="{{ route('contactForm.submit') }}")>
    <x-honeypot livewire-model="extraFields" />
    <input name="myField" type="text">
</form>

Usage with a Content Security Policy

By default, the honeypot fields are hidden using an inline style attribute. If your Content Security Policy doesn't allow inline styles, set with_csp in the config file to true (or set HONEYPOT_WITH_CSP=true). The fields will then be hidden using a <style> tag that carries a nonce.

This relies on the @cspNonce directive, so you'll need to install spatie/laravel-csp first.

Usage in Volt functional syntax

To use this package in Volt functional syntax, return the HoneypotData property from the guessHoneypotDataProperty method.

use App\Models\User;
use Spatie\Honeypot\Http\Livewire\Concerns\HoneypotData;
use Spatie\Honeypot\Http\Livewire\Concerns\UsesSpamProtection;
use function Livewire\Volt\{uses, state, mount};

uses(UsesSpamProtection::class);

state([
    // ...
    'extraFields' => null,
]);

mount(function () {
    $this->extraFields = new HoneypotData();
});

$guessHoneypotDataProperty = fn () => $this->extraFields;

$submit = function () {
    $this->protectAgainstSpam(); // if is spam, will abort the request
    
    User::create($request->all());
};

Disabling in testing

By default, any protected form that is submitted in faster than 1 second will be marked as spammy. When running end to end tests, which should run as fast as possible, you probably don't want this.

To disable all honeypots in code, you can set the enabled config value to false.

config()->set('honeypot.enabled', false)

Customizing the response

When a spammy submission is detected, the package will show a blank page by default. You can customize this behaviour by writing your own SpamResponse and specifying its fully qualified class name in the respond_to_spam_with key of the honeypot config file.

A valid SpamResponse is any class that implements the Spatie\Honeypot\SpamResponder\SpamResponder interface. This is what that interface looks like:

namespace Spatie\Honeypot\SpamResponder;

use Closure;
use Illuminate\Http\Request;

interface SpamResponder
{
    public function respond(Request $request, Closure $next);
}

Even though a spam responder's primary purpose is to respond to spammy requests, you could do other stuff there as well. You could for instance use the properties on $request to determine the source of the spam (maybe all requests come from the same IP) and put some logic to block that source altogether.

If the package wrongly determined that the request is spammy, you can generate the default response by passing the $request to the $next closure, like you would in a middleware.

// in your spam responder
$regularResponse = $next($request)

Customizing the generated honeypot fields

To customize output generated, you can publish the honeypot view with:

php artisan vendor:publish --provider="Spatie\Honeypot\HoneypotServiceProvider" --tag=honeypot-views

The view will be placed in resources/views/vendor/honeypot/honeypotFormFields.blade.php. This is the default content:

@if($enabled)
    

@endif

Events fired

Whenever spam is detected, the Spatie\Honeypot\Events\SpamDetectedEvent event is fired. It has the $request as a public property.

Testing

composer test

Changelog

Please see CHANGELOG for more information on what has changed recently.

Alternatives

If you need stronger spam protection, consider using Google ReCaptcha or Akismet.

Contributing

Pleas