diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..2982143
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,35 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: true
+      matrix:
+        php: [8.2, 8.3, 8.4]
+
+    name: PHP ${{ matrix.php }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite
+          coverage: none
+
+      - name: Install dependencies
+        run: composer install --prefer-dist --no-interaction --no-progress
+
+      - name: Run tests
+        run: vendor/bin/pest
diff --git a/.gitignore b/.gitignore
index cb756e9..e12d770 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 vendor
-.idea
\ No newline at end of file
+.idea
+.phpunit.cache
diff --git a/CLAUDE.md b/CLAUDE.md
index 1a57d6a..2fd77c3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -32,6 +32,15 @@ The `accessToken` can be set:
 1. **Globally** via `config/filament-userback.php` - applies to all panels
 2. **Per-panel** via `->accessToken()` method - overrides global config
 
+The `only_authenticated` setting controls whether the widget is shown only to authenticated users:
+1. **Globally** via `config/filament-userback.php` (default: `true`)
+2. **Per-panel** via `->onlyAuthenticated()` method - overrides global config
+
+The `guard` setting specifies which authentication guard to use:
+1. **Per-panel** via `->guard()` method - highest priority
+2. **Globally** via `config/filament-userback.php`
+3. **Fallback** to the panel's configured auth guard (`$panel->getAuthGuard()`)
+
 ## Common Tasks
 
 ### Testing the plugin locally
diff --git a/composer.json b/composer.json
index 00d9c71..01b0d7d 100644
--- a/composer.json
+++ b/composer.json
@@ -15,11 +15,21 @@
         "illuminate/contracts": "^11.0|^12.0",
         "spatie/laravel-package-tools": "^1.16"
     },
+    "require-dev": {
+        "orchestra/testbench": "^9.0|^10.0",
+        "pestphp/pest": "^3.0",
+        "pestphp/pest-plugin-laravel": "^3.0"
+    },
     "autoload": {
         "psr-4": {
             "CoddinWeb\\FilamentUserback\\": "src/"
         }
     },
+    "autoload-dev": {
+        "psr-4": {
+            "CoddinWeb\\FilamentUserback\\Tests\\": "tests/"
+        }
+    },
     "extra": {
         "laravel": {
             "providers": [
@@ -27,6 +37,14 @@
             ]
         }
     },
+    "scripts": {
+        "test": "vendor/bin/pest"
+    },
+    "config": {
+        "allow-plugins": {
+            "pestphp/pest-plugin": true
+        }
+    },
     "minimum-stability": "dev",
     "prefer-stable": true
 }
diff --git a/config/filament-userback.php b/config/filament-userback.php
index 422ea6c..5864062 100644
--- a/config/filament-userback.php
+++ b/config/filament-userback.php
@@ -17,4 +17,32 @@
     */
 
     'access_token' => env('USERBACK_ACCESS_TOKEN'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Only Authenticated Users
+    |--------------------------------------------------------------------------
+    |
+    | When set to true, the Userback widget will only be rendered for
+    | authenticated users. Set to false to show the widget to all visitors.
+    |
+    | This can be overridden per-panel using the ->onlyAuthenticated() method.
+    |
+    */
+
+    'only_authenticated' => env('USERBACK_ONLY_AUTHENTICATED', true),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Guard
+    |--------------------------------------------------------------------------
+    |
+    | The authentication guard to use when checking if a user is authenticated.
+    | If not set, it will fall back to the panel's configured auth guard.
+    |
+    | This can be overridden per-panel using the ->guard() method.
+    |
+    */
+
+    'guard' => env('USERBACK_GUARD'),
 ];
diff --git a/phpunit.xml b/phpunit.xml
new file mode 100644
index 0000000..8848452
--- /dev/null
+++ b/phpunit.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         cacheDirectory=".phpunit.cache"
+>
+    <testsuites>
+        <testsuite name="Tests">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory>src</directory>
+        </include>
+    </source>
+</phpunit>
diff --git a/resources/views/userback.blade.php b/resources/views/userback.blade.php
index 4cd7989..bbef6e3 100644
--- a/resources/views/userback.blade.php
+++ b/resources/views/userback.blade.php
@@ -1,4 +1,4 @@
-@if(\is_string($accessToken))
+@if(\is_string($accessToken) && (!$onlyAuthenticated || auth($guard)->check()))
 <script>
     window.Userback = window.Userback || {};
     Userback.access_token = @js($accessToken);
diff --git a/src/UserbackPlugin.php b/src/UserbackPlugin.php
index ce1913f..eebaadd 100644
--- a/src/UserbackPlugin.php
+++ b/src/UserbackPlugin.php
@@ -16,6 +16,10 @@ class UserbackPlugin implements Plugin
 {
     protected ?string $accessToken = null;
 
+    protected ?bool $onlyAuthenticated = null;
+
+    protected ?string $guard = null;
+
     protected ?Closure $userDataUsing = null;
 
     public static function make(): static
@@ -42,6 +46,20 @@ public function userDataUsing(?Closure $callback): static
         return $this;
     }
 
+    public function onlyAuthenticated(bool $onlyAuthenticated = true): static
+    {
+        $this->onlyAuthenticated = $onlyAuthenticated;
+
+        return $this;
+    }
+
+    public function guard(?string $guard): static
+    {
+        $this->guard = $guard;
+
+        return $this;
+    }
+
     public function register(Panel $panel): void
     {
     }
@@ -63,6 +81,8 @@ public function boot(Panel $panel): void
                 [
                     'accessToken' => $this->getAccessToken(),
                     'userData' => $this->getUserData(),
+                    'onlyAuthenticated' => $this->getOnlyAuthenticated(),
+                    'guard' => $this->getGuard($panel),
                 ],
             ),
         );
@@ -89,6 +109,43 @@ protected function getAccessToken(): ?string
         return null;
     }
 
+    protected function getOnlyAuthenticated(): bool
+    {
+        if (\is_bool($this->onlyAuthenticated)) {
+            return $this->onlyAuthenticated;
+        }
+
+        $configValue = Config::get('filament-userback.only_authenticated');
+
+        return \is_bool($configValue) ? $configValue : true;
+    }
+
+    protected function getGuard(Panel $panel): ?string
+    {
+        $guard = null;
+
+        if (\is_string($this->guard)) {
+            $guard = $this->guard;
+        } elseif (\is_string($configGuard = Config::get('filament-userback.guard'))) {
+            $guard = $configGuard;
+        } else {
+            $guard = $panel->getAuthGuard();
+        }
+
+        return $this->isValidGuard($guard) ? $guard : null;
+    }
+
+    protected function isValidGuard(?string $guard): bool
+    {
+        if ($guard === null) {
+            return true;
+        }
+
+        $guards = Config::get('auth.guards', []);
+
+        return \is_array($guards) && \array_key_exists($guard, $guards);
+    }
+
     /**
      * @return array<string, mixed>|null
      */
diff --git a/tests/ConfigurationTest.php b/tests/ConfigurationTest.php
new file mode 100644
index 0000000..345c203
--- /dev/null
+++ b/tests/ConfigurationTest.php
@@ -0,0 +1,172 @@
+<?php
+
+declare(strict_types=1);
+
+use CoddinWeb\FilamentUserback\UserbackPlugin;
+use Illuminate\Support\Facades\Auth;
+
+beforeEach(function () {
+    // Reset config before each test
+    config()->set('filament-userback.access_token', null);
+    config()->set('filament-userback.only_authenticated', null);
+    config()->set('filament-userback.guard', null);
+});
+
+describe('access token configuration', function () {
+    it('renders widget when access token is set via config', function () {
+        config()->set('filament-userback.access_token', 'config-token');
+
+        $html = $this->renderUserbackView(
+            accessToken: 'config-token',
+            userData: null,
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)
+            ->toContain('Userback.access_token')
+            ->toContain('config-token');
+    });
+
+    it('renders widget when access token is set via plugin method', function () {
+        $html = $this->renderUserbackView(
+            accessToken: 'plugin-token',
+            userData: null,
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)
+            ->toContain('Userback.access_token')
+            ->toContain('plugin-token');
+    });
+
+    it('does not render widget when no access token is configured', function () {
+        $html = $this->renderUserbackView(
+            accessToken: null,
+            userData: null,
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)->toBe('');
+    });
+});
+
+describe('only_authenticated configuration', function () {
+    it('renders widget for unauthenticated users when only_authenticated is false', function () {
+        Auth::shouldReceive('guard')->with(null)->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(false);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)->toContain('Userback.access_token');
+    });
+
+    it('does not render widget for unauthenticated users when only_authenticated is true', function () {
+        Auth::shouldReceive('guard')->with(null)->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(false);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: true,
+            guard: null
+        );
+
+        expect($html)->toBe('');
+    });
+
+    it('renders widget for authenticated users when only_authenticated is true', function () {
+        Auth::shouldReceive('guard')->with(null)->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(true);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: true,
+            guard: null
+        );
+
+        expect($html)->toContain('Userback.access_token');
+    });
+});
+
+describe('guard configuration', function () {
+    it('uses default guard when no guard is specified', function () {
+        Auth::shouldReceive('guard')->with(null)->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(true);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: true,
+            guard: null
+        );
+
+        expect($html)->toContain('Userback.access_token');
+    });
+
+    it('uses specified guard for auth check', function () {
+        Auth::shouldReceive('guard')->with('admin')->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(true);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: true,
+            guard: 'admin'
+        );
+
+        expect($html)->toContain('Userback.access_token');
+    });
+
+    it('respects guard auth state', function () {
+        Auth::shouldReceive('guard')->with('admin')->andReturnSelf();
+        Auth::shouldReceive('check')->andReturn(false);
+
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: true,
+            guard: 'admin'
+        );
+
+        expect($html)->toBe('');
+    });
+});
+
+describe('user data configuration', function () {
+    it('renders user data when provided', function () {
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: ['id' => 123, 'info' => ['name' => 'John Doe', 'email' => 'john@example.com']],
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)
+            ->toContain('Userback.user_data')
+            ->toContain('123')
+            ->toContain('John Doe')
+            ->toContain('john@example.com');
+    });
+
+    it('does not render user data when not provided', function () {
+        $html = $this->renderUserbackView(
+            accessToken: 'test-token',
+            userData: null,
+            onlyAuthenticated: false,
+            guard: null
+        );
+
+        expect($html)
+            ->toContain('Userback.access_token')
+            ->not->toContain('Userback.user_data');
+    });
+});
diff --git a/tests/Pest.php b/tests/Pest.php
new file mode 100644
index 0000000..d375ba0
--- /dev/null
+++ b/tests/Pest.php
@@ -0,0 +1,7 @@
+<?php
+
+declare(strict_types=1);
+
+use CoddinWeb\FilamentUserback\Tests\TestCase;
+
+pest()->extends(TestCase::class)->in(__DIR__);
diff --git a/tests/TestCase.php b/tests/TestCase.php
new file mode 100644
index 0000000..8e8c400
--- /dev/null
+++ b/tests/TestCase.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CoddinWeb\FilamentUserback\Tests;
+
+use CoddinWeb\FilamentUserback\FilamentUserbackServiceProvider;
+use CoddinWeb\FilamentUserback\UserbackPlugin;
+use Filament\FilamentServiceProvider;
+use Filament\Panel;
+use Filament\PanelProvider;
+use Filament\Support\SupportServiceProvider;
+use Illuminate\Foundation\Auth\User;
+use Livewire\LivewireServiceProvider;
+use Orchestra\Testbench\TestCase as Orchestra;
+
+abstract class TestCase extends Orchestra
+{
+    protected function getPackageProviders($app): array
+    {
+        return [
+            LivewireServiceProvider::class,
+            FilamentServiceProvider::class,
+            SupportServiceProvider::class,
+            FilamentUserbackServiceProvider::class,
+        ];
+    }
+
+    protected function defineEnvironment($app): void
+    {
+        $app['config']->set('database.default', 'testing');
+        $app['config']->set('database.connections.testing', [
+            'driver' => 'sqlite',
+            'database' => ':memory:',
+        ]);
+
+        $app['config']->set('auth.providers.users.model', User::class);
+    }
+
+    protected function createPanel(UserbackPlugin $plugin, ?string $authGuard = null): Panel
+    {
+        $panel = Panel::make()
+            ->id('test')
+            ->path('test')
+            ->plugin($plugin);
+
+        if ($authGuard !== null) {
+            $panel->authGuard($authGuard);
+        }
+
+        return $panel;
+    }
+
+    protected function bootPluginWithPanel(UserbackPlugin $plugin, ?string $authGuard = null): void
+    {
+        $panel = $this->createPanel($plugin, $authGuard);
+        $plugin->boot($panel);
+    }
+
+    protected function renderUserbackView(
+        ?string $accessToken,
+        ?array $userData,
+        bool $onlyAuthenticated,
+        ?string $guard
+    ): string {
+        return view('filament-userback::userback', [
+            'accessToken' => $accessToken,
+            'userData' => $userData,
+            'onlyAuthenticated' => $onlyAuthenticated,
+            'guard' => $guard,
+        ])->render();
+    }
+}
diff --git a/tests/UserbackPluginTest.php b/tests/UserbackPluginTest.php
new file mode 100644
index 0000000..d5331b3
--- /dev/null
+++ b/tests/UserbackPluginTest.php
@@ -0,0 +1,181 @@
+<?php
+
+declare(strict_types=1);
+
+use CoddinWeb\FilamentUserback\UserbackPlugin;
+use Filament\Panel;
+
+beforeEach(function () {
+    config()->set('filament-userback.access_token', null);
+    config()->set('filament-userback.only_authenticated', null);
+    config()->set('filament-userback.guard', null);
+});
+
+describe('plugin instantiation', function () {
+    it('can be instantiated via make()', function () {
+        $plugin = UserbackPlugin::make();
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('returns correct plugin id', function () {
+        $plugin = UserbackPlugin::make();
+
+        expect($plugin->getId())->toBe('userback');
+    });
+});
+
+describe('fluent configuration', function () {
+    it('can set access token', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('my-token');
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('can set user data callback', function () {
+        $plugin = UserbackPlugin::make()
+            ->userDataUsing(fn () => ['id' => 1, 'name' => 'Test User']);
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('can enable only authenticated mode', function () {
+        $plugin = UserbackPlugin::make()
+            ->onlyAuthenticated(true);
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('can disable only authenticated mode', function () {
+        $plugin = UserbackPlugin::make()
+            ->onlyAuthenticated(false);
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('can set guard', function () {
+        $plugin = UserbackPlugin::make()
+            ->guard('admin');
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+
+    it('can chain all configuration methods', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('my-token')
+            ->userDataUsing(fn () => ['id' => 1])
+            ->onlyAuthenticated(true)
+            ->guard('web');
+
+        expect($plugin)->toBeInstanceOf(UserbackPlugin::class);
+    });
+});
+
+describe('panel integration', function () {
+    it('can be registered with a panel', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        $panel = $this->createPanel($plugin);
+
+        expect($panel->getPlugin('userback'))->toBe($plugin);
+    });
+
+    it('can boot with a panel', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        // Should not throw
+        $this->bootPluginWithPanel($plugin);
+
+        expect(true)->toBeTrue();
+    });
+
+    it('uses panel auth guard as fallback', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        $panel = $this->createPanel($plugin, 'admin');
+
+        expect($panel->getAuthGuard())->toBe('admin');
+    });
+});
+
+describe('config fallback behavior', function () {
+    it('uses config access token when not set on plugin', function () {
+        config()->set('filament-userback.access_token', 'config-token');
+
+        $plugin = UserbackPlugin::make();
+        $panel = $this->createPanel($plugin);
+
+        // Boot and check render hook is registered
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue(); // Plugin boots without error
+    });
+
+    it('uses config only_authenticated when not set on plugin', function () {
+        config()->set('filament-userback.only_authenticated', false);
+
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        $panel = $this->createPanel($plugin);
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue();
+    });
+
+    it('uses config guard when not set on plugin', function () {
+        config()->set('filament-userback.guard', 'api');
+
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        $panel = $this->createPanel($plugin);
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue();
+    });
+});
+
+describe('guard validation', function () {
+    it('boots without error when guard is valid', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token')
+            ->guard('web');
+
+        $panel = $this->createPanel($plugin);
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue();
+    });
+
+    it('boots without error when guard is invalid', function () {
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token')
+            ->guard('nonexistent-guard');
+
+        $panel = $this->createPanel($plugin);
+
+        // Should not throw - invalid guard is converted to null
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue();
+    });
+
+    it('boots without error when config guard is invalid', function () {
+        config()->set('filament-userback.guard', 'nonexistent-guard');
+
+        $plugin = UserbackPlugin::make()
+            ->accessToken('test-token');
+
+        $panel = $this->createPanel($plugin);
+
+        // Should not throw - invalid guard is converted to null
+        $plugin->boot($panel);
+
+        expect(true)->toBeTrue();
+    });
+});