Verifica umana senza tracciamento

# AgentHouse HumanProof

Blocca bot e spam su moduli HTML — senza cookie, fingerprinting o widget CAPTCHA di terze parti. Un file JavaScript e una verifica lato server; la prova gira in background.

Nessun cookie

Script in un file

Verificato lato server

## Un’alternativa moderna ai CAPTCHA

I CAPTCHA classici rallentano, peggiorano l’accessibilità e spesso caricano script di terze parti invasivi. HumanProof usa una challenge firmata a breve vita e proof-of-work leggero nel browser — nessun puzzle, immagine o widget extra.

* Nessun fingerprinting né profilo di tracciamento cross-site da una rete di widget.
* Nessun Google o fornitore CAPTCHA esterno obbligatorio sulla pagina.
* I segreti restano sul server: il browser non ha mai la chiave di verifica.

## Come funziona

Dalla challenge all’invio verificato in quattro passaggi.

* L'SDK richiede una challenge firmata per la site key pubblica e l'id modulo.
* Il browser risolve una piccola proof-of-work (fuori dal main thread se possibile).
* La prova è allegata come campo nascosto all'invio del modulo.
* Il server chiama l'API di verifica con la chiave segreta e riceve accept, quarantine o fake-success.

## Pensato per siti privacy-first

Adatto a team attenti al GDPR e hosting UE-first: superficie ridotta, nessuno script ad-tech sul modulo.

* Nessun cookie richiesto per il widget.
* Il traffico resta tra la vostra origine e l’API AgentHouse — nessuno script di reti pubblicitarie.
* Lato verifica, logging minimo e attento alla retention.
* Decidete voi come reagire a ogni esito — accetta, quarantena o fake-success — sul vostro backend.

## Un solo file JavaScript — nient’altro

Niente npm, bundler o framework: caricate uno script dall’API AgentHouse, impostate gli attributi data sui moduli e avete finito. Uno script può proteggere più moduli nella stessa pagina. Riga “Powered by AgentHouse” opzionale inclusa di default.

## Integrazione amichevole per gli sviluppatori

Front-end: uno script. Back-end: una POST JSON per verificare. Funziona con qualsiasi stack — Node.js, PHP, Python o qualsiasi cosa che chiami HTTPS.

Back-end: inviate lo stesso corpo JSON a POST …/humanproof/verify. La risposta include status, suggestedAction, reasonCode e accept (booleano — true solo quando la richiesta va trattata come invio verificato). Solo dal server: non mandate mai il secretKey al browser.

Alcuni form richiedono il campo hostname in verify (deve coincidere con boundHost nel payload client — l’host usato alla richiesta della challenge). Con requireVerifyHostname attivo, senza hostname l’API risponde reasonCode HOSTNAME\_REQUIRED. 127.0.0.1 e localhost sono distinti; includeteli entrambi in hostnames oppure allineate URL del sito e data-challenge-hostname al body di verify.

Gli URL script/API seguono la configurazione (produzione: api.agenthouse.org; humanproof.publicSdkBase per dev).

Se allo submit lo SDK deve richiedere la challenge e risolvere il PoW, emette su window il CustomEvent humanproof.securingForm (detail: form, siteKey, formId) per mostrare avanzamento. In caso di errore: humanproof-error sul form.

```
window.addEventListener('humanproof.securingForm', function (e) { /* e.detail.form, siteKey, formId */ });
```

Il PoW richiede prima la challenge dal server. Opzionale: data-prefetch-challenge-delay-ms sullo script (ms dopo il load) per scaricare la challenge e risolvere in background; all’invio si riusa la prova se ancora valida. data-prefetch-expiry-margin-ms impone quel margine di TTL residuo (skew orologio). Per form: data-humanproof-prefetch-challenge-delay-ms e data-humanproof-prefetch-expiry-margin-ms.

HTML HTML multi-modulo Node.js PHP Python 

```
<form id="contact-form" data-humanproof="YOUR_FORM_ID">
  <label>Email <input type="email" name="email" required></label>
  <button type="submit">Send</button>
</form>
<script
  src="https://api.agenthouse.org/humanproof/humanproof.js"
  data-site-key="YOUR_PUBLIC_SITE_KEY"
  data-powered-by="true"
  data-endpoint="https://api.agenthouse.org/humanproof"
  data-prefetch-challenge-delay-ms="2500"
  data-prefetch-expiry-margin-ms="15000"
></script>
```

```
<form id="a" data-humanproof="form-a">...</form>
<form id="b" data-humanproof="form-b">...</form>
<script
  src="https://api.agenthouse.org/humanproof/humanproof.js"
  data-site-key="YOUR_PUBLIC_SITE_KEY"
  data-powered-by="true"
  data-endpoint="https://api.agenthouse.org/humanproof"
  data-prefetch-challenge-delay-ms="2500"
  data-prefetch-expiry-margin-ms="15000"
></script>
```

```
const verifyUrl = 'https://api.agenthouse.org/humanproof/verify';
const secretKey = ''; // set from your secrets store before use
const payload = JSON.parse(formFields.humanproof);
const body = { secretKey, ...payload };
if (typeof body.hostname !== 'string' || !body.hostname.trim()) {
  if (typeof body.boundHost === 'string' && body.boundHost.trim()) {
    body.hostname = body.boundHost.trim();
  }
}
const result = await (await fetch(verifyUrl, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(body)
})).json();
if (!result.accept) return; // do not process as a verified submit
```

```
<?php
$url = 'https://api.agenthouse.org/humanproof/verify';
$secret = ''; // set from your server secret store before use
$payload = json_decode($_POST['humanproof'], true);
$body = array_merge(['secretKey' => $secret], $payload);
if (empty($body['hostname']) && !empty($body['boundHost'])) {
  $body['hostname'] = $body['boundHost'];
}
$ch = curl_init($url);
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
  CURLOPT_POSTFIELDS => json_encode($body),
  CURLOPT_RETURNTRANSFER => true,
]);
$out = curl_exec($ch);
$result = json_decode($out, true);
// if (empty($result['accept'])) { return; }
?>
```

```
import json
import urllib.request

VERIFY_URL = "https://api.agenthouse.org/humanproof/verify"

def verify_humanproof(secret_key: str, payload: dict) -> dict:
    body = {"secretKey": secret_key, **payload}
    if not (isinstance(body.get("hostname"), str) and body["hostname"].strip()):
        bh = body.get("boundHost")
        if isinstance(bh, str) and bh.strip():
            body["hostname"] = bh.strip()
    req = urllib.request.Request(
        VERIFY_URL,
        data=json.dumps(body).encode("utf-8"),
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        r = json.load(resp)
    # if not r.get("accept"): return
    return r
```

## Branding

HumanProof mostra di default una breve riga «Powered by AgentHouse». Rimuovetela con un abbonamento mensile semplice — stesso prodotto, stesse garanzie privacy.

* Riga «Powered by» inclusa nel piano gratuito.
* Il piano a pagamento nasconde la riga; comportamento e verifica restano identici.
* Contattateci quando volete attivare la licenza.

## Perché i team scelgono HumanProof

Vantaggi concreti per prodotto e compliance.

* Meno interruzioni dei CAPTCHA a immagini o puzzle — niente nuovi clic per gli utenti.
* Accessibilità migliore: nessuno step visivo obbligatorio, compatibile con flussi da tastiera.
* Privacy solida: nessun CAPTCHA di terze parti né widget pubblicitario sul modulo.
* Rapido da integrare: uno script, un’API di verifica, esempi per backend comuni.
* Policy sotto il vostro controllo: difficoltà per modulo e gestione degli invii sospetti.

## Provalo dal vivo

Inviate il modulo sotto: la proof-of-work gira in background, poi la demo invia al nostro server (nessun salvataggio).

Nome 

Email 

Azienda 

Messaggio 

Invia modulo 

### Risultato demo

OK 

## Inizia a proteggere i moduli

Configurate site key e regole per modulo in AgentHouse, aggiungete lo script e verificate ogni invio sul backend. È tutta l’integrazione — siamo qui per il rollout.

[Inizia](/it/consulting/#cta)