Salta al contenuto principale

07 - PerplexityBot e Perplexity-User: robots.txt

Due agenti, regole diverse: che cosa controlla robots.txt secondo la RFC 9309, come verificare dai log chi ti visita e che cosa ha riferito Cloudflare.

Cosa ne pensi di questo articolo?

07 - PerplexityBot e Perplexity-User: robots.txt
Perplexityfedericocalo.dev

In Breve

Due agenti, regole diverse: che cosa controlla robots.txt secondo la RFC 9309, come verificare dai log chi ti visita e che cosa ha riferito Cloudflare.

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

PerplexityBotPerplexity-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 baseAzioni 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 pubblicatihttps://www.perplexity.ai/perplexitybot.jsonhttps://www.perplexity.ai/perplexity-user.json
robots.txtSi consiglia di consentirlo per comparire nei risultatiIn 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

SceltaDirettiveEffetto atteso (dalla documentazione)
Consenti tuttoUser-agent: PerplexityBot + Allow: /; nessuna regola per Perplexity-UserPuoi comparire nei risultati; le visite su richiesta dell'utente non sono bloccate
Vieta solo l'indiceUser-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.txtDisallow: / per entrambiPer 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-UserRegola del WAF o del server, combinando User-Agent e intervalli IPBlocco 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 provaUser-AgentIPAtteso
1, 2PerplexityBotdue indirizzi nell'elencocoerente
3PerplexityBotIPv6 dentro un prefisso dell'elencocoerente
4PerplexityBotindirizzo fuori dall'elencoimitazione
5Perplexity-Userindirizzo nel suo elencocoerente
6Perplexity-Userindirizzo dell'elenco di PerplexityBotnon coerente
7, 8Chrome su macOSindirizzo qualunquenon attribuibile
9Googlebotindirizzo qualunquenon attribuibile
10riga 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.

← Articolo 6: costi, QPS e 429 Articolo 8: farsi citare →

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

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti