Product: Bot Protection

CAPTCHA Protection

Invisible human verification that protects your forms without frustrating your users. No puzzles. No image grids. Just security.

Try Live Demo Platform Integrations

Interactive Demo

Experience Invisible CAPTCHA

Fill out this form normally - no puzzles or images to solve. Watch as SilentAuth analyzes your behavior in real-time.

Try the Demo

Fill out this form - no CAPTCHA puzzles!

Live Behavior Signals

These signals are being collected invisibly as you interact with the form.

Mouse Moves

Keystrokes

Time on Page

Focus Events

How it works

As you fill out the form, SilentAuth analyzes your mouse movements, typing patterns, and interaction timing. Bots can't replicate natural human behavior, so they get low scores and are blocked - while real users sail through without seeing any challenges.

Why Choose Invisible CAPTCHA?

SilentAuth uses behavioral analysis, device fingerprinting, and risk scoring to distinguish humans from bots - all without user interaction.

Zero Friction

Real users never see a challenge. Verification happens invisibly in the background using behavioral signals.

GDPR Compliant

No tracking cookies, no cross-site identifiers, no data selling. Privacy-first architecture.

99.9% Accuracy

Industry-leading detection rates with minimal false positives through ML-powered risk scoring.

How to Integrate

A complete step-by-step guide to implementing invisible bot protection on your forms.

Step 01

Add Script to Your Page

Include the SilentAuth script on pages with forms you want to protect. One line of code, async loading.

<script src="https://sdk.silentauth.com/captcha.js"
  data-project="your-project-id" async></script>

Step 02

User Interacts Normally

As users browse and fill out your form, SilentAuth silently analyzes behavioral patterns, device signals, and interaction timing.

Mouse movement patterns

Keystroke dynamics

Touch gestures on mobile

Canvas & WebGL fingerprinting

Server-bound challenge nonces

Time-on-page analysis

Step 03

Get Verification Token

When the user submits the form, call verify() to get a cryptographic token proving they're human.

const token = await SilentAuth.verify({
  action: 'contact_form'
});

// Include token in your form submission
formData.append('sa_token', token);

Step 04

Validate on Your Server

Send the token to your backend. Make a server-side API call to validate it before processing the form.

// Server-side validation (Node.js example)
const response = await fetch(
  'https://api.silentauth.com/v1/verify',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_SECRET_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ token: req.body.sa_token })
  }
);

const result = await response.json();
if (result.success && result.score >= 0.5) {
  // Process the form - user is human
} else {
  // Block submission - likely a bot
}

Step 05

Action Processed

If validation passes, process the form normally. Bots are blocked, real users sail through without ever seeing a challenge.

Full audit log available

Risk score breakdown

Threat intelligence data

Geolocation context

Platform Integrations

Works with every stack

SilentAuth integrates in minutes regardless of your framework. Pick your platform and follow the guide — server-side validation is supported in any language via the REST API.

React Next.js Vue / Nuxt PHP / Laravel Python / Django Plain HTML

React

Use the official React hook for seamless integration with any React app, including Vite, Create React App, and Remix.

npm install @silentauth/react

import { useSilentAuth } from '@silentauth/react';

export function ContactForm() {
  const { verify, isReady } = useSilentAuth({
    projectId: process.env.NEXT_PUBLIC_SA_PROJECT_ID,
  });

  const handleSubmit = async (e) => {
    e.preventDefault();
    const token = await verify({ action: 'contact_form' });

    await fetch('/api/contact', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ ...formData, sa_token: token }),
    });
  };

  return (
    <form onSubmit={handleSubmit}>
      {/* your form fields */}
      <button type="submit" disabled={!isReady}>Send</button>
    </form>
  );
}

Next.js

Full-stack integration with React hook on the frontend and a Route Handler for server-side validation.

npm install @silentauth/react @silentauth/sdk

// app/components/ContactForm.tsx  (client component)
'use client';
import { useSilentAuth } from '@silentauth/react';

export function ContactForm() {
  const { verify } = useSilentAuth({
    projectId: process.env.NEXT_PUBLIC_SA_PROJECT_ID!,
  });

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    const token = await verify({ action: 'contact_form' });
    await fetch('/api/contact', {
      method: 'POST',
      body: JSON.stringify({ ...formData, sa_token: token }),
    });
  };
  // ...
}

// app/api/contact/route.ts  (server route handler)
import { SilentAuth } from '@silentauth/sdk';

const sa = new SilentAuth({ secretKey: process.env.SA_SECRET_KEY! });

export async function POST(req: Request) {
  const { sa_token, ...data } = await req.json();
  const result = await sa.verify(sa_token);
  if (!result.success || result.score < 0.5) {
    return Response.json({ error: 'Bot detected' }, { status: 403 });
  }
  // process form...
  return Response.json({ ok: true });
}

Vue / Nuxt

Use the Vue composable for Vue 3 projects, including Nuxt 3 with server-side validation in API routes.

npm install @silentauth/vue

<!-- ContactForm.vue -->
<script setup>
import { useSilentAuth } from '@silentauth/vue';

const { verify, isReady } = useSilentAuth({
  projectId: import.meta.env.VITE_SA_PROJECT_ID,
});

async function handleSubmit() {
  const token = await verify({ action: 'contact_form' });
  await $fetch('/api/contact', {
    method: 'POST',
    body: { ...formData, sa_token: token },
  });
}
</script>

<template>
  <form @submit.prevent="handleSubmit">
    <!-- your form fields -->
    <button type="submit" :disabled="!isReady">Send</button>
  </form>
</template>

PHP / Laravel

Add the script tag to your Blade templates and validate with the PHP SDK or the REST API directly.

composer require silentauth/silentauth-php

{{-- resources/views/contact.blade.php --}}
<script src="https://sdk.silentauth.com/captcha.js"
  data-project="{{ config('silentauth.project_id') }}" async></script>

<form id="contact-form" method="POST" action="/contact">
  @csrf
  {{-- your form fields --}}
  <input type="hidden" name="sa_token" id="sa_token">
  <button type="submit">Send</button>
</form>

<script>
document.getElementById('contact-form')
  .addEventListener('submit', async (e) => {
    e.preventDefault();
    const token = await SilentAuth.verify({ action: 'contact_form' });
    document.getElementById('sa_token').value = token;
    e.target.submit();
  });
</script>

// app/Http/Controllers/ContactController.php
use SilentAuth\SilentAuth;

public function store(Request $request)
{
    $sa = new SilentAuth(['secret_key' => config('silentauth.secret_key')]);
    $result = $sa->verify($request->input('sa_token'));

    if (!$result['success'] || $result['score'] < 0.5) {
        abort(403, 'Bot detected');
    }
    // process form...
}

Python / Django

Drop the script into your Django templates and verify tokens server-side with the Python SDK.

pip install silentauth

{# templates/contact.html #}
<script src="https://sdk.silentauth.com/captcha.js"
  data-project="{{ SA_PROJECT_ID }}" async></script>

<form id="contact-form" method="post">
  {% csrf_token %}
  {# your form fields #}
  <input type="hidden" name="sa_token" id="sa_token">
  <button type="submit">Send</button>
</form>

<script>
document.getElementById('contact-form')
  .addEventListener('submit', async (e) => {
    e.preventDefault();
    const token = await SilentAuth.verify({ action: 'contact_form' });
    document.getElementById('sa_token').value = token;
    e.target.submit();
  });
</script>

# views.py
from silentauth import SilentAuth
import os

sa = SilentAuth(secret_key=os.environ['SA_SECRET_KEY'])

def contact(request):
    if request.method == 'POST':
        result = sa.verify(request.POST.get('sa_token'))
        if not result['success'] or result['score'] < 0.5:
            return HttpResponseForbidden('Bot detected')
        # process form...

Plain HTML

No framework needed. Drop two snippets into any HTML page and validate with any backend via the REST API.

<!-- 1. Add to <head> or before </body> -->
<script src="https://sdk.silentauth.com/captcha.js"
  data-project="YOUR_PROJECT_ID" async></script>

<!-- 2. Your form -->
<form id="my-form">
  <input type="text" name="email" placeholder="Email">
  <input type="hidden" name="sa_token" id="sa_token">
  <button type="submit">Submit</button>
</form>

<script>
document.getElementById('my-form')
  .addEventListener('submit', async function (e) {
    e.preventDefault();
    const token = await SilentAuth.verify({ action: 'form_submit' });
    document.getElementById('sa_token').value = token;
    this.submit();
  });
</script>

# Backend: validate via REST API (any language)
# POST https://api.silentauth.com/v1/verify
# Authorization: Bearer YOUR_SECRET_KEY
# { "token": "<sa_token>" }
# → { "success": true, "score": 0.97, "action": "form_submit" }

Using WordPress?

Install the official SilentAuth WordPress plugin (v5.3.3) — handles forms, login pages, and comments with zero code. Includes server-bound nonce verification and WebGL fingerprinting.

Download Plugin

SilentAuth vs Traditional CAPTCHA

See why invisible verification is the future of bot protection.

Feature	SilentAuth	Traditional CAPTCHA
User friction	None	High - puzzles/images
Mobile experience	Seamless	Poor - tiny images
Accessibility	Full - no visual challenges	Limited - audio fallback
Bot detection	Behavioral + ML + nonce binding	Image recognition
Privacy	No tracking cookies	Cross-site tracking

Common Use Cases

Protect any form or user interaction from automated abuse.

Login and registration forms
Contact and lead generation forms
E-commerce checkout protection
Comment and review spam prevention
Newsletter signup protection
Password reset forms

Complete Integration Example

// Frontend: React form example
import { SilentAuth } from '@silentauth/sdk';

function ContactForm() {
  const handleSubmit = async (e) => {
    e.preventDefault();

    // Get verification token
    const token = await SilentAuth.verify({
      action: 'contact_form'
    });

    // Submit with token
    await fetch('/api/contact', {
      method: 'POST',
      body: JSON.stringify({
        ...formData,
        sa_token: token
      })
    });
  };

  return <form onSubmit={handleSubmit}>...</form>;
}

Ready to protect your forms?

Start free with 10,000 verifications/month. No credit card required.

Get Started Free