Risposta diretta. Perplexity dichiara due agenti diversi, con regole diverse. PerplexityBot serve a far comparire e linkare i siti nei risultati di ricerca di Perplexity, e la documentazione consiglia di consentirlo in robots.txt e di accettare le richieste dagli indirizzi pubblicati. Perplexity-User visita una pagina perché una persona ha fatto una domanda e, dice la stessa pagina, in generale ignora robots.txt perché la richiesta è dell'utente. Le impostazioni sono indipendenti e le modifiche possono richiedere fino a 24 ore. Ne discende che robots.txt governa il primo agente e non il secondo: per limitare il secondo servono controlli sul server. E c'è un limite che nessun file risolve: nell'agosto 2025 Cloudflare ha pubblicato un'analisi su traffico attribuito a Perplexity con identità non dichiarata, quindi ciò che puoi verificare è ciò che mostrano i tuoi log.
I due agenti, come dichiarati
| PerplexityBot | Perplexity-User | |
|---|---|---|
| A cosa serve (dichiarato) | Far comparire e linkare i siti nei risultati di ricerca; non è usato per raccogliere contenuti per l'addestramento dei modelli di base | Azioni avviate dall'utente: quando una persona fa una domanda può visitare una pagina per rispondere e linkarla; non è usato per scansione né per l'addestramento |
| User-Agent di esempio (il numero di versione può cambiare) | Mozilla/5.0 (compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot) | Mozilla/5.0 (compatible; Perplexity-User/1.0; +https://perplexity.ai/perplexity-user) |
| Indirizzi IP pubblicati | https://www.perplexity.ai/perplexitybot.json | https://www.perplexity.ai/perplexity-user.json |
robots.txt | Si consiglia di consentirlo per comparire nei risultati | In generale ignorato, perché la richiesta è dell'utente |
Attenzione a chi dichiara cosa: «non è usato per l'addestramento» è un'affermazione del fornitore e dall'esterno non c'è modo di verificarla. La puoi mettere in conto come impegno pubblico, non come fatto accertato. La stessa pagina descrive anche come configurare un firewall applicativo (WAF) per consentire i due agenti, e dice che gli indirizzi vanno presi dai file JSON, che sono la fonte di verità e vengono aggiornati con regolarità.
Che cosa scrivere in robots.txt, e che cosa produce
| Scelta | Direttive | Effetto atteso (dalla documentazione) |
|---|---|---|
| Consenti tutto | User-agent: PerplexityBot + Allow: /; nessuna regola per Perplexity-User | Puoi comparire nei risultati; le visite su richiesta dell'utente non sono bloccate |
| Vieta solo l'indice | User-agent: PerplexityBot + Disallow: / | Non fai parte dei risultati costruiti da quell'agente; una persona che incolla il tuo URL può comunque far partire una visita |
| Vieta entrambi in robots.txt | Disallow: / per entrambi | Per il primo robots.txt è lo strumento indicato dalla pagina; per il secondo, per la documentazione, in generale no: il divieto per Perplexity-User è solo dichiarativo |
| Vieta davvero Perplexity-User | Regola del WAF o del server, combinando User-Agent e intervalli IP | Blocco effettivo, con i limiti dell'identificazione (più sotto) |
Una verità scomoda sulle direttive: il file che questo sito pubblica per i due agenti è Allow: / per entrambi, con in più Crawl-delay: 5 per PerplexityBot. Crawl-delay non fa parte dello standard di robots.txt (RFC 9309) e nella pagina di Perplexity che ho riletto oggi non compare: quella riga è una speranza, non un controllo. La scrivo perché non costa nulla, ma non la conto fra le protezioni.
robots.txt secondo la RFC 9309, non secondo l'abitudine
Prima di scrivere una regola conviene sapere come verrà letta. La RFC 9309 dice tre cose che contano: vince la regola più specifica, cioè quella con più ottetti, e a parità vince allow; i crawler devono supportare * (zero o più caratteri qualunque) e $ (fine del percorso); e, in una frase sola, le regole non sono una forma di autorizzazione all'accesso. Il programma qui sotto le implementa e le confronta con urllib.robotparser, il lettore della libreria standard di Python, su un robots.txt di prova per un negozio: Allow: / in testa, poi Disallow: /carrello e Disallow: /*?filtro=, un gruppo per Perplexity-User e un User-agent: * che vieta tutto.
"""Che cosa dice robots.txt a un agente, secondo RFC 9309, confrontato con urllib.robotparser.
RFC 9309 (settembre 2022), sezioni 2.2.2 e 2.2.3: vince la regola con più ottetti, a parità
vince allow, e i crawler devono supportare «*» (zero o più caratteri) e «$» (fine del percorso).
"""
import random
import re
import sys
import urllib.robotparser
from urllib.parse import urlsplit
def leggi_gruppi(testo):
gruppi, agenti, regole, nelle_regole = [], [], [], False
for riga in testo.splitlines():
riga = riga.split("#", 1)[0].strip()
if ":" not in riga:
continue
campo, valore = (p.strip() for p in riga.split(":", 1))
campo = campo.lower()
if campo == "user-agent":
if nelle_regole:
gruppi.append((agenti, regole))
agenti, regole, nelle_regole = [], [], False
agenti = [*agenti, valore.lower()]
elif campo in ("allow", "disallow"):
nelle_regole = True
if valore: # «Disallow:» vuoto non vieta nulla
regole = [*regole, (campo == "allow", valore)]
if agenti:
gruppi.append((agenti, regole))
return gruppi
def corrisponde(pattern, percorso):
fine = pattern.endswith("$")
corpo = pattern[:-1] if fine else pattern
espressione = ".*".join(re.escape(p) for p in corpo.split("*")) + ("$" if fine else "")
return re.match(espressione, percorso) is not None
def consentito(testo, agente, url):
parti = urlsplit(url)
percorso = parti.path + (f"?{parti.query}" if parti.query else "")
gruppi = leggi_gruppi(testo)
scelti = [g for g in gruppi if agente.lower() in g[0]] or [g for g in gruppi if "*" in g[0]]
regole = [r for _, rs in scelti for r in rs]
trovate = [(len(p.encode()), permesso) for permesso, p in regole if corrisponde(p, percorso)]
if not trovate:
return True
return max(trovate)[1] # più ottetti; a parità True (allow) > False
def riferimento(pattern, s):
"""Secondo calcolo, scritto in modo diverso: ricorsione sul pattern."""
if pattern == "":
return True
if pattern == "$":
return s == ""
if pattern[0] == "*":
return any(riferimento(pattern[1:], s[i:]) for i in range(len(s) + 1))
return s != "" and s[0] == pattern[0] and riferimento(pattern[1:], s[1:])
if __name__ == "__main__":
testo = open(sys.argv[1], encoding="utf-8").read()
pb = urllib.robotparser.RobotFileParser()
pb.parse(testo.splitlines())
prove = [
("PerplexityBot", "https://negozio.test/"),
("PerplexityBot", "https://negozio.test/prodotti/tenda-2p"),
("PerplexityBot", "https://negozio.test/carrello"),
("PerplexityBot", "https://negozio.test/prodotti/tenda-2p?filtro=rosso"),
("Perplexity-User", "https://negozio.test/prodotti/tenda-2p"),
("Perplexity-User", "https://negozio.test/area-riservata/pratica-1"),
("AltroBot", "https://negozio.test/prodotti/tenda-2p"),
]
print(f"{'agente':16}{'URL (percorso)':36}{'RFC 9309':>9}{'robotparser':>13}")
for agente, url in prove:
a, b = consentito(testo, agente, url), pb.can_fetch(agente, url)
percorso = urlsplit(url).path + ("?" + urlsplit(url).query if urlsplit(url).query else "")
print(f"{agente:16}{percorso:36}{str(a):>9}{str(b):>13}{' <- differiscono' if a != b else ''}")
print("Crawl-delay letto da robotparser per PerplexityBot:", pb.crawl_delay("PerplexityBot"))
# Stessa regola «Allow: /», spostata in fondo al gruppo: robotparser usa la prima che corrisponde.
invertito = testo.replace("Allow: /\n", "").replace("Disallow: /*?filtro=\n", "Disallow: /*?filtro=\nAllow: /\n")
pb2 = urllib.robotparser.RobotFileParser()
pb2.parse(invertito.splitlines())
for nome, url in (("/carrello", "https://negozio.test/carrello"),
("?filtro=", "https://negozio.test/prodotti/tenda-2p?filtro=rosso")):
print(f"Allow in fondo, {nome:10} robotparser {str(pb2.can_fetch('PerplexityBot', url)):5}"
f" RFC 9309 {consentito(invertito, 'PerplexityBot', url)}")
print("Python", sys.version.split()[0])
rng = random.Random(3)
patterns = ["/*?filtro=", "/carrello", "/*.pdf$", "/a/*/b", "/", "/x$"]
alfabeto = "/ab.?=xpdf"
coppie = 0
for _ in range(5000):
s = "/" + "".join(rng.choice(alfabeto) for _ in range(rng.randint(0, 9)))
for p in patterns:
assert corrisponde(p, s) == riferimento(p, s), (p, s)
coppie += 1
print(f"confronto con la ricorsione su {coppie} coppie pattern/percorso: concordano")
# Comando: python3 regole.py robots_negozio.txt
# Output:
# agente URL (percorso) RFC 9309 robotparser
# PerplexityBot / True True
# PerplexityBot /prodotti/tenda-2p True True
# PerplexityBot /carrello False True <- differiscono
# PerplexityBot /prodotti/tenda-2p?filtro=rosso False True <- differiscono
# Perplexity-User /prodotti/tenda-2p True True
# Perplexity-User /area-riservata/pratica-1 False False
# AltroBot /prodotti/tenda-2p False False
# Crawl-delay letto da robotparser per PerplexityBot: 5
# Allow in fondo, /carrello robotparser False RFC 9309 False
# Allow in fondo, ?filtro= robotparser True RFC 9309 False
# Python 3.14.4
# confronto con la ricorsione su 30000 coppie pattern/percorso: concordano
Il confronto smentisce un'abitudine comune. Per PerplexityBot la RFC vieta /carrello (la regola ha più ottetti di Allow: /) e vieta l'URL con ?filtro= (il carattere jolly corrisponde), mentre robotparser li lascia passare entrambi: prende la prima regola che corrisponde, e Allow: / è la prima; quando la sposto in fondo il carrello viene vietato anche da lui, ma il filtro con il jolly resta consentito, perché quel lettore non supporta * nei percorsi. Per la RFC il lettore Python è meno preciso del testo: se verifichi le tue regole con una libreria, controlla come tratta ordine e jolly. Non so come li tratti il crawler di Perplexity: la sua pagina non lo dice. Il confronto finale, con una ricorsione scritta in modo diverso su 30.000 coppie, conferma solo che la mia implementazione corrisponde alla RFC; il risultato vale per Python 3.14.4 e non l'ho provato su altre versioni.
La riga Crawl-delay: 5 viene letta da robotparser (la sua interfaccia restituisce 5), e questo prova solo che il lettore la conosce: la RFC non la definisce. L'altra frase da ricordare è l'ultima: un file pubblico che elenca percorsi non è un controllo d'accesso, e rivela perfino quali sono i percorsi che non vuoi mostrare.
Che cosa è verificabile: i tuoi log
L'unica verifica indipendente è guardare chi ha bussato. Il metodo: classifica ogni riga del log per User-Agent, poi controlla se l'indirizzo IP rientra negli intervalli pubblicati per quell'agente. Un User-Agent che dice «PerplexityBot» da un IP fuori dai suoi intervalli è un'imitazione, non il crawler. Il programma legge il formato combined di nginx e i due file JSON nella forma pubblicata (una chiave creationTime e un array prefixes di oggetti con ipv4Prefix; gestisce anche ipv6Prefix, che nei file di oggi non compare). Lo provo su un log e su due file di indirizzi costruiti da me con gli intervalli riservati alla documentazione (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24, 2001:db8::/32), non su traffico vero.
| Riga del log di prova | User-Agent | IP | Atteso |
|---|---|---|---|
| 1, 2 | PerplexityBot | due indirizzi nell'elenco | coerente |
| 3 | PerplexityBot | IPv6 dentro un prefisso dell'elenco | coerente |
| 4 | PerplexityBot | indirizzo fuori dall'elenco | imitazione |
| 5 | Perplexity-User | indirizzo nel suo elenco | coerente |
| 6 | Perplexity-User | indirizzo dell'elenco di PerplexityBot | non coerente |
| 7, 8 | Chrome su macOS | indirizzo qualunque | non attribuibile |
| 9 | Googlebot | indirizzo qualunque | non attribuibile |
| 10 | riga troncata, fuori formato | ||
La tabella dice che cosa ho messo nel file di prova, così l'uscita si confronta con ciò che deve produrre. Nel programma, la funzione analizza riconosce l'agente dichiarato con l'espressione regolare, sceglie la lista di indirizzi di quell'agente e conta l'esito; una riga che non rispetta il formato non fa fallire l'analisi e viene contata a parte.
"""Verifica dai log chi dichiara di essere Perplexity e se l'IP è fra quelli pubblicati.
Formato atteso: «combined» di nginx. I file JSON hanno la forma pubblicata da Perplexity:
{"creationTime": ..., "prefixes": [{"ipv4Prefix": "..."}]} (gestiti anche ipv6Prefix).
"""
import ipaddress
import json
import re
import sys
from collections import Counter
COMBINED = re.compile(r'^(\S+) \S+ \S+ \[[^\]]+\] "[^"]*" \d{3} \S+ "[^"]*" "([^"]*)"$')
DICHIARATI = re.compile(r"(PerplexityBot|Perplexity-User)", re.I)
def carica_reti(percorso):
with open(percorso, encoding="utf-8") as f:
dati = json.load(f)
return [ipaddress.ip_network(p[k]) for p in dati.get("prefixes", [])
for k in ("ipv4Prefix", "ipv6Prefix") if k in p]
def analizza(righe, reti_bot, reti_user):
esiti, illeggibili = Counter(), 0
for riga in righe:
m = COMBINED.match(riga.rstrip("\n"))
if not m:
illeggibili += 1
continue
ip, ua = m.groups()
dichiarato = DICHIARATI.search(ua)
if not dichiarato:
esiti["altro User-Agent (non attribuibile)"] += 1
continue
agente = dichiarato.group(1).lower()
reti = reti_bot if agente == "perplexitybot" else reti_user
coerente = any(ipaddress.ip_address(ip) in rete for rete in reti)
esiti[f"{agente}: {'IP coerente' if coerente else 'IP NON coerente'}"] += 1
return esiti, illeggibili
if __name__ == "__main__":
log, f_bot, f_user = sys.argv[1:4]
with open(log, encoding="utf-8", errors="replace") as f:
esiti, illeggibili = analizza(f, carica_reti(f_bot), carica_reti(f_user))
for chiave, n in sorted(esiti.items()):
print(f"{n:>3} {chiave}")
print(f"{illeggibili:>3} righe non nel formato combined")
# Comando: python3 log_agenti.py accesso.log
# Output:
# 3 altro User-Agent (non attribuibile)
# 1 perplexity-user: IP NON coerente
# 1 perplexity-user: IP coerente
# 1 perplexitybot: IP NON coerente
# 3 perplexitybot: IP coerente
# 1 righe non nel formato combined
I conteggi coincidono con la tabella, e coincidono con un controllo indipendente fatto con grep -c sul file (4 righe con PerplexityBot, 2 con Perplexity-User). Il risultato più istruttivo è però ciò che il programma non sa dire: le tre righe «non attribuibili» sono tre richieste che un normale browser, o un altro crawler, avrebbe prodotto uguali. Il programma risponde a una domanda precisa, le richieste che si dichiarano Perplexity vengono davvero dagli indirizzi pubblicati?, e non a quella che conta per chi vuole bloccare: quanto traffico di Perplexity arriva senza dichiararsi. Per quella non esiste un metodo affidabile dall'esterno, se non euristiche probabilistiche, che sbagliano. Ricarica i due file periodicamente: la documentazione li indica come fonte di verità.
L'analisi di Cloudflare del 4 agosto 2025, per quel che dice
Cloudflare ha pubblicato i risultati di test condotti su domini nuovi, mai indicizzati, con un robots.txt che vietava ogni accesso e regole WAF che bloccavano i due agenti dichiarati. Interrogando Perplexity su quei domini, ha riferito di aver ottenuto risposte dettagliate sui contenuti. Ha osservato, oltre all'agente dichiarato, un User-Agent generico da Chrome su macOS, da indirizzi non presenti negli intervalli pubblicati, con rotazione di IP e di sistemi autonomi (ASN). Le stime riportate sono 20-25 milioni di richieste al giorno per gli agenti dichiarati e 3-6 milioni per l'identità non dichiarata, quest'ultima su decine di migliaia di domini; Cloudflare dice di aver riconosciuto il secondo traffico con apprendimento automatico e segnali di rete. In seguito ha tolto Perplexity dall'elenco dei bot verificati e ha aggiunto euristiche alle regole gestite.
Come usarla: è l'analisi di un fornitore di sicurezza sui propri test, relativa a un periodo preciso, e nella pagina letta non c'è una replica di Perplexity (non l'ho cercata altrove). La stessa Cloudflare scrive che il comportamento osservato sarebbe quasi certamente cambiato dopo la pubblicazione. Non dimostra che oggi si ripeta e non lo smentisce: la risposta professionale è «se questo conta per te, misura nei tuoi log e predisponi un blocco che non dipenda dalla cortesia del bot».
Se decidi di bloccare: la regola sul server
La pagina di Perplexity descrive per il WAF di Cloudflare una regola che combina User-Agent e indirizzo, e avverte che la «Bot Fight Mode» non si può saltare con le regole personalizzate: può quindi sfidare questi agenti anche quando li hai consentiti. Per bloccare l'imitazione la logica è la stessa rovesciata: un User-Agent che dichiara PerplexityBot ma un indirizzo fuori dall'elenco. Quella seguente è la regola della documentazione, seguita da un mio adattamento.
# 1) Consentire: User-Agent E indirizzo pubblicato, per ciascun agente (forma della documentazione)
(http.user_agent contains "PerplexityBot" and ip.src in {<intervalli di PerplexityBot>})
or (http.user_agent contains "Perplexity-User" and ip.src in {<intervalli di Perplexity-User>})
# 2) Bloccare le imitazioni: dice di essere PerplexityBot ma l'indirizzo non è fra quelli pubblicati
# (adattamento mio, non provato su Cloudflare)
(http.user_agent contains "PerplexityBot" and not ip.src in {<intervalli di PerplexityBot>})
Lo schema è da adattare e non l'ho eseguito: i segnaposto fra parentesi angolari vanno sostituiti con gli intervalli presi dai due file JSON, e il secondo blocco è un adattamento mio che non ho provato su Cloudflare. La regola 1 è da mettere sopra le regole che bloccano o sfidano, perché un'azione «Skip» salta solo ciò che viene dopo; la regola 2 blocca. Qualunque regola va riletta ogni volta che i file cambiano, e una configurazione sbagliata può bloccare l'agente che volevi consentire.
Due decisioni, dichiarate come scenari
Un negozio che non vuole i filtri nell'indice
Ipotesi: un negozio online con migliaia di schede e URL di filtro generati da parametri vuole consentire le schede, ma non carrello e pagine filtrate. Scrive Disallow: /carrello e Disallow: /*?filtro=. Cosa cambia: secondo la RFC il jolly va supportato, ma non so se lo supporti il crawler di Perplexity e il lettore di Python, come hai visto, non lo fa. Prova: guarda nei log quali percorsi vengono davvero chiesti dopo la modifica.
Un portale con pagine pubbliche e aree riservate
Ipotesi: una struttura sanitaria o un comune ha un portale con pagine pubbliche e un'area riservata, e pensa che Disallow: /area-riservata protegga. Non protegge: la RFC dice che le regole non sono un'autorizzazione e il file elenca i percorsi a chiunque. Rimedio: l'area riservata sta dietro autenticazione, e si verifica con una richiesta senza credenziali che nessun contenuto personale risponda 200.
Che cosa sai fare adesso
Sai distinguere i due agenti dichiarati e dire che cosa robots.txt controlla per ciascuno, sai che il lettore della libreria standard di Python e la RFC 9309 non dicono la stessa cosa su ordine e jolly, sai controllare dai log se chi si dichiara Perplexity viene dagli indirizzi pubblicati, e sai che il traffico non dichiarato non lo vedrai con questo metodo. Se vuoi un blocco vero, serve una regola sul server. Il quadro delle API di Perplexity sta nell'articolo 1, e che cosa aspettarti dalla visibilità, una volta consentito il crawler, nell'articolo 8 qui sotto.
Domande frequenti
Perplexity rispetta robots.txt?
Secondo la documentazione, PerplexityBot è l'agente per cui si consiglia di consentire l'accesso in robots.txt; Perplexity-User, che agisce su richiesta di un utente, in generale lo ignora. Le due impostazioni sono indipendenti e le modifiche possono richiedere fino a 24 ore.
Come blocco Perplexity-User?
Con robots.txt non basta, perché in generale viene ignorato. Serve una regola sul server o sul WAF che combini User-Agent e intervalli IP pubblicati nel file perplexity-user.json.
Come verifico che una richiesta sia davvero PerplexityBot?
Confronta l'indirizzo IP con gli intervalli del file perplexitybot.json: un User-Agent che si dichiara PerplexityBot da un IP fuori dagli intervalli è un'imitazione.
Perplexity usa crawler non dichiarati?
Cloudflare lo ha riferito il 4 agosto 2025, con stime di 3-6 milioni di richieste al giorno per l'identità non dichiarata. Non ho misurato il comportamento attuale: per il tuo sito l'unica evidenza è nei tuoi log.
Fonti
- Perplexity, Perplexity Crawlers - descrizione dei due agenti, User-Agent di esempio, comportamento rispetto a robots.txt, configurazione del WAF; letta per intero il 13 novembre 2026, la pagina non riporta data
- Perplexity, indirizzi IP di PerplexityBot e di Perplexity-User - forma dei file, numero di prefissi e
creationTime; scaricati il 13 novembre 2026 - Cloudflare, Perplexity is using stealth, undeclared crawlers to evade website no-crawl directives - metodo dei test, stime delle richieste, provvedimenti di Cloudflare (4 agosto 2025); letta per intero il 13 novembre 2026
- IETF, RFC 9309: Robots Exclusion Protocol - regola della corrispondenza più specifica, caratteri speciali «*» e «$», frase sull'autorizzazione all'accesso; sezioni 1, 2.2.2 e 2.2.3 lette il 13 novembre 2026
Commenti
Caricamento commenti...
Accedi per commentare