Risposta diretta. Nessuno fuori da Perplexity può dirti con prove perché una pagina venga citata e un'altra no. La documentazione ufficiale per sviluppatori dice poche cose: PerplexityBot serve a far comparire e linkare i siti nei risultati di ricerca e se ne consiglia il consenso, Perplexity-User visita le pagine quando una persona fa una domanda. Da questo discende un solo prerequisito documentato: non bloccare PerplexityBot. Tutto il resto, dalla struttura del testo alla freschezza, circola come «tecnica», ma è nella migliore delle ipotesi una congettura ragionevole. Questo articolo separa ciò che è documentato da ciò che è plausibile e da ciò che è solo ripetuto, ti dà un sondaggio che puoi ripetere con il rumore misurato, e chiude la serie con il riepilogo degli otto articoli.
Tre colonne: documentato, plausibile, ripetuto
| Documentato dal fornitore | Plausibile ma non dimostrato | Ripetuto da terzi, senza fonte primaria che io abbia aperto |
|---|---|---|
| PerplexityBot fa comparire e linkare i siti nei risultati e se ne consiglia il consenso in robots.txt. Perplexity-User visita pagine su richiesta di un utente e in generale ignora robots.txt. Le modifiche a robots.txt richiedono fino a 24 ore. Gli intervalli IP sono pubblicati in due file JSON. | Testo chiaro, risposta in apertura, date visibili, HTML completo senza dipendere da JavaScript, URL stabili, sitemap con date vere, identità dell'autore esplicita. | Pesi dei «segnali» (autorità, freschezza, struttura), preferenza per fonti «della community», lunghezza ideale dei paragrafi, numero medio di citazioni per risposta, esecuzione o meno di JavaScript da parte del crawler. |
La colonna centrale non è un elenco di trucchi: è un elenco di cose che migliorano il sito per i lettori e per qualunque crawler. Il criterio per includerle è che se la congettura è sbagliata, non hai perso nulla: scrivere una risposta nelle prime righe di una pagina, o mostrare la data di aggiornamento, serve comunque a chi legge. Le pratiche che costano molto per un beneficio ipotetico (riscritture massicce, pagine fatte apposta per i motori) non le consiglio.
Che cosa si può misurare davvero
Quattro misure, ciascuna con il suo limite. Nessuna ti dice «quanto sei citato»:
- Visite del crawler (log del server). Quante richieste di PerplexityBot per URL, con gli indirizzi verificati contro il file ufficiale, come nell'articolo 7. Limite: essere visitati non significa essere citati.
- Visite da perplexity.ai (analytics). Le persone che hanno cliccato una fonte. Limite: sottostima, perché non tutte le citazioni vengono cliccate e non tutti i browser passano il referrer.
- Un sondaggio con la Search API. Le tue domande, filtrate sul tuo dominio, registrando se i tuoi URL compaiono fra i risultati. Limite: misura se le tue pagine sono recuperabili dalla Search API, non cosa cita l'applicazione.
- Prove manuali. Le stesse domande nell'applicazione. Limite: le risposte variano fra una prova e l'altra, e una singola apparizione non prova nulla né vale come tendenza.
Le quattro misure guardano punti diversi della stessa catena (visita, indice, risposta, clic) e non sono sommabili: un numero alto nella prima e nulla nella terza è un'informazione, non una contraddizione. Per il terzo punto, la pagina «Search API: overview» che ho letto non dice che indice e ordinamento coincidano con quelli dell'applicazione per i consumatori, quindi non lo assumo. Il sondaggio è la sola misura che puoi ripetere identica ogni settimana, ed è quella che costruiamo adesso.
Un sondaggio ripetibile, e quanto rumore c'è
Il programma seguente contiene la logica del sondaggio e la prova contro una ricerca finta: la funzione cerca viene iniettata e qui restituisce elenchi costruiti a mano (due risultati di altri siti e, per alcune domande, uno del tuo dominio example.com). Nulla di ciò che stampa viene da Perplexity. La funzione sondaggio registra per ogni domanda quanti URL del tuo dominio compaiono, e quota è la frazione di domande con almeno un URL tuo. Poi misura il rumore: se i due sondaggi avessero la stessa probabilità vera di successo (0,5 per semplicità), con quante domande di scarto ti ingannerebbero?
"""Sondaggio di recuperabilità: la logica, provata contro una ricerca FINTA (non è Perplexity).
La funzione `cerca` è iniettata: in produzione sarebbe la chiamata alla Search API, qui è un
elenco di risultati costruito a mano. Prezzi dalla pagina Pricing di Perplexity (2026-11-13).
"""
import math
import random
from fractions import Fraction
from types import SimpleNamespace as Risultato
from urllib.parse import urlsplit
DOMINIO = "example.com"
DOMANDE = [
"come scegliere gli scarponi da trekking", "peso medio di uno zaino per tre giorni",
"come si lava una giacca impermeabile", "tenda a due posti o a tre stagioni",
"come leggere una mappa escursionistica", "che cosa mettere in un kit di pronto soccorso",
"differenza fra piumino e pile", "come impermeabilizzare le scarpe",
"sacco a pelo temperatura di comfort", "quanta acqua portare in una gita di un giorno",
"bastoncini da trekking telescopici o pieghevoli", "come si ripara una tenda strappata",
"scarponi o scarpe basse in estate", "come stringere bene gli scarponi in discesa",
"calze tecniche in lana o sintetiche", "come scegliere uno zaino da 40 litri",
"frontale con quanti lumen", "come asciugare l'attrezzatura bagnata",
"come preparare un itinerario di tre giorni", "guanti leggeri per la primavera",
]
def ricerca_finta(indici_tuoi):
"""Per le domande negli indici restituisce anche un URL del tuo dominio."""
def cerca(domanda):
i = DOMANDE.index(domanda)
altri = [Risultato(url=f"https://altro-{i}.test/a"), Risultato(url=f"https://rivista-{i}.test/b")]
mio = [Risultato(url=f"https://{DOMINIO}/guida-{i}")] if i in indici_tuoi else []
return altri + mio
return cerca
def sondaggio(cerca, domande, dominio, giorno):
righe = []
for domanda in domande:
tuoi = [r.url for r in cerca(domanda) if (urlsplit(r.url).hostname or "").endswith(dominio)]
righe.append({"data": giorno, "domanda": domanda, "n_url_tuoi": len(tuoi), "url": tuoi})
return righe
def quota(righe):
return sum(1 for r in righe if r["n_url_tuoi"] > 0) / len(righe)
def prob_differenza(n, p, soglia):
"""Probabilità esatta che due sondaggi da n domande, con la stessa p vera, differiscano di almeno `soglia` domande."""
pm = [math.comb(n, k) * p**k * (1 - p) ** (n - k) for k in range(n + 1)]
return sum(pm[a] * pm[b] for a in range(n + 1) for b in range(n + 1) if abs(a - b) >= soglia)
if __name__ == "__main__":
a = sondaggio(ricerca_finta(set(range(0, 18, 2))), DOMANDE, DOMINIO, "2026-11-06")
b = sondaggio(ricerca_finta({0, 1, 2, 4, 6, 8, 10, 12, 13, 14, 16}), DOMANDE, DOMINIO, "2026-11-13")
print(f"settimana A: {quota(a):.2f} settimana B: {quota(b):.2f} differenza {quota(b) - quota(a):+.2f}")
n, p = len(DOMANDE), 0.5
for soglia in (2, 6):
print(f"se nulla fosse cambiato, differenza >= {soglia}/{n} domande con probabilità {prob_differenza(n, p, soglia):.3f}")
rng = random.Random(11) # controllo: simulazione a seme fisso
prove = 20000
sim = sum(abs(sum(rng.random() < p for _ in range(n)) - sum(rng.random() < p for _ in range(n))) >= 2
for _ in range(prove)) / prove
print(f"simulazione ({prove} coppie): {sim:.3f} contro esatto {prob_differenza(n, p, 2):.3f}")
assert abs(sim - prob_differenza(n, p, 2)) < 0.01
richieste_mese = len(DOMANDE) * 4 # 20 domande a settimana
standard = Fraction(richieste_mese) * Fraction("5.00") / 1000
fast = Fraction(richieste_mese) * Fraction("1.00") / 1000
print(f"{richieste_mese} richieste al mese: {float(standard):.2f} $ standard, {float(fast):.2f} $ con search_type fast")
# Comando: python3 sondaggio.py
# Output:
# settimana A: 0.45 settimana B: 0.55 differenza +0.10
# se nulla fosse cambiato, differenza >= 2/20 domande con probabilità 0.636
# se nulla fosse cambiato, differenza >= 6/20 domande con probabilità 0.081
# simulazione (20000 coppie): 0.634 contro esatto 0.636
# 80 richieste al mese: 0.40 $ standard, 0.08 $ con search_type fast
I due sondaggi finti differiscono di 0,10, cioè due domande su venti: se nulla fosse cambiato, uno scarto di almeno due domande capita con probabilità 0,636, quindi quasi due volte su tre. Servono differenze molto più grandi (sei domande, 0,30) per scendere all'8%. Il valore esatto viene dalla convoluzione di due binomiali e la simulazione a seme fisso su ventimila coppie lo conferma (0,634 contro 0,636). La conclusione pratica è quella della prudenza: con venti domande considera significative solo variazioni ampie e durature, non il confronto fra due settimane. Il costo, con i prezzi della pagina Pricing, è di 0,40 dollari al mese in modalità standard (80 richieste a 5,00 dollari ogni mille) o 0,08 con search_type: "fast".
Per passare dal finto al vero basta sostituire la funzione iniettata con una chiamata alla Search API. Lo schema qui sotto usa solo parametri della pagina «Search API: overview»: query, max_results (da 1 a 20), country (codice ISO 3166-1 alpha-2) e search_domain_filter (fino a 20 domini, in sola inclusione o in sola esclusione con il prefisso -). È uno schema da adattare: non l'ho eseguito, non ho una chiave, non l'ho mai inviato. Con il filtro sul tuo dominio chiedi «tra le pagine di questo sito, quali sono recuperabili per questa domanda?», non «il mio sito batte gli altri?»: per la seconda dovresti cercare senza filtro e guardare la posizione.
from perplexity import Perplexity # pip install perplexityai (versione 0.46.1 il 13 novembre 2026)
client = Perplexity() # legge PERPLEXITY_API_KEY dall'ambiente
def cerca_reale(domanda):
return client.search.create(
query=domanda,
max_results=10,
country="IT",
search_domain_filter=["example.com"], # lista consentita: solo il tuo dominio
).results
Ciò che posso validare senza il prodotto è la forma. Il programma seguente legge lo schema come testo, lo analizza con ast senza importare il pacchetto, e controlla i nomi dei parametri contro l'elenco documentato e i limiti sopra. Lo provo anche su una copia volutamente sbagliata (prova_errata.py: un parametro modello che non esiste, max_results=50 e country="Italia"). Una forma valida non prova che la risposta sia quella che ti aspetti: prova solo che non invii una richiesta malformata.
"""Controlla solo la FORMA della richiesta in schema_ricerca.py: non importa il pacchetto, non invia nulla.
Parametri e limiti dalla pagina «Search API: overview» di Perplexity, consultata il 2026-11-13.
"""
import ast
import sys
PARAMETRI = {
"query", "max_results", "search_type", "max_tokens", "max_tokens_per_page",
"search_domain_filter", "search_language_filter", "search_recency_filter",
"search_after_date_filter", "search_before_date_filter",
"last_updated_after_filter", "last_updated_before_filter", "country",
}
def chiamate_create(albero):
for nodo in ast.walk(albero):
if (isinstance(nodo, ast.Call) and isinstance(nodo.func, ast.Attribute)
and nodo.func.attr == "create"):
yield nodo
def controlla(codice):
albero = ast.parse(codice) # sintassi valida?
problemi = []
for chiamata in chiamate_create(albero):
kw = {k.arg: k.value for k in chiamata.keywords}
sconosciuti = set(kw) - PARAMETRI
if sconosciuti:
problemi.append(f"parametri non documentati: {sorted(sconosciuti)}")
if "max_results" in kw and not 1 <= ast.literal_eval(kw["max_results"]) <= 20:
problemi.append("max_results fuori da 1-20")
if "country" in kw:
c = ast.literal_eval(kw["country"])
if not (len(c) == 2 and c.isalpha() and c.isupper()):
problemi.append("country non è un codice ISO 3166-1 alpha-2")
if "search_domain_filter" in kw:
d = ast.literal_eval(kw["search_domain_filter"])
if len(d) > 20:
problemi.append("più di 20 domini nel filtro")
if len({x.startswith("-") for x in d}) > 1:
problemi.append("filtro misto: una sola modalità per richiesta")
yield sorted(kw), problemi
if __name__ == "__main__":
for percorso in sys.argv[1:]:
with open(percorso, encoding="utf-8") as f:
trovate = list(controlla(f.read()))
print(f"{percorso}: {len(trovate)} chiamata create()")
for parametri, problemi in trovate:
print(" parametri:", ", ".join(parametri))
print(" problemi:", problemi or "nessuno")
print("nessuna richiesta inviata")
# Comando: python3 forma_richiesta.py schema_ricerca.py
# Output:
# schema_ricerca.py: 1 chiamata create()
# parametri: country, max_results, query, search_domain_filter
# problemi: nessuno
# prova_errata.py: 1 chiamata create()
# parametri: country, max_results, modello, query, search_domain_filter
# problemi: ["parametri non documentati: ['modello']", 'max_results fuori da 1-20', 'country non è un codice ISO 3166-1 alpha-2']
# nessuna richiesta inviata
Lo schema giusto passa senza problemi, la copia sbagliata ne segnala tre, uno per errore. Il nome del pacchetto e la forma dell'importazione vengono dalla pagina della Search API (pip install perplexityai, importato come perplexity); la versione 0.46.1 è l'ultima sul registro PyPI il 13 novembre 2026. Registra ogni esecuzione con la data nel file, e considera i numeri come una serie temporale con un margine d'errore noto, non come un punteggio.
Che cosa scelgo di non scrivere
- Percentuali di miglioramento della citazione dopo questa o quella modifica: non ho trovato misure indipendenti e riproducibili.
- «Perplexity non esegue JavaScript» come fatto: l'ho incontrato come affermazione ripetuta, non nella documentazione ufficiale. Pubblicare HTML completo lato server resta una buona pratica a prescindere, ma non la presento come causa di citazioni.
- Una checklist per «posizionarsi su Perplexity»: se la vendi come garanzia, ti sta vendendo una congettura.
- Dati di questo sito. Il sito consente PerplexityBot in
robots.txt, ma non pubblico numeri di citazione perché non li ho misurati con un metodo che reggerebbe una critica.
Sono quattro rinunce della stessa natura: una cifra o una regola senza una misura che chiunque possa rifare. Ho preferito lasciare il vuoto e dichiararlo, perché in questo campo un numero inventato circola più in fretta di una smentita. Se trovi una misura indipendente e riproducibile, è lì che vale la pena aggiornare questa pagina.
Due scenari dichiarati: la citazione fuori contesto
Uno studio professionale con un blog di approfondimenti
Ipotesi: uno studio di avvocati pubblica un articolo al mese e consente PerplexityBot. Cosa cambia: data di pubblicazione e di ultima verifica in apertura, ambito del testo (a quale norma e a quale data si riferisce), e il sondaggio mensile. Il valore atteso non è il traffico: è che chi riceve una risposta sintetica con una fonte veda il nome dello studio. Cosa va storto: una norma cambia e l'articolo resta citato nella versione vecchia, oppure la risposta attribuisce allo studio un'affermazione che l'articolo non faceva. Rimedio: revisione programmata, avviso in cima alle pagine invecchiate, e la regola che nessun articolo sostituisce un parere. Se essere citati porti clienti non lo so, e non lo prometto.
L'associazione di quartiere e il volantino
Ipotesi: la pro loco di un paese pubblica il programma della sagra come immagine di un volantino. Cosa cambia: una pagina con il programma scritto in testo, data e luogo in apertura, leggibile anche da chi chiede a un assistente «cosa c'è nel weekend in paese». Cosa va storto: la data cambia e la risposta, per giorni, riporta quella vecchia: ogni modifica va fatta nella pagina, non solo sui social. E chi cerca orari o parcheggi deve aprire la fonte citata invece di fidarsi della sintesi.
La serie in una pagina
Gli otto articoli, nell'ordine in cui conviene leggerli:
- 01 - Perplexity per sviluppatori: la mappa: le cinque API in una tabella, un primo esempio per ciascuna, il trade-off fra Agent API e Search API e che fine hanno fatto i modelli Sonar.
- 02 - Agent API di Perplexity: effort e citazioni: i livelli di effort, le fonti citate, filtri e strumenti, esecuzioni lunghe.
- 03 - Search API di Perplexity per la tua RAG: i parametri della richiesta, una pipeline con fonti verificabili e il conto delle cinque query in una richiesta.
- 04 - Da Sonar all'Agent API: migrare senza danni: prima e dopo nel codice, che cosa sparisce e un piano in cinque passi.
- 05 - Perplexity MCP in Claude Code e Cursor: server remoto o locale, configurazioni senza chiavi in chiaro e il web nel contesto dell'assistente.
- 06 - Costi, QPS e 429 con l'API di Perplexity: i due limiti dell'Agent API, i tre 429 e un tetto di spesa tuo.
- 07 - PerplexityBot e Perplexity-User: robots.txt: due agenti con regole diverse, robots.txt secondo la RFC 9309 e la verifica dai log.
- 08 - Farsi citare da Perplexity: cosa è provato: questa pagina, su ciò che è documentato, ciò che è congettura e come misurare il resto.
L'ordine segue il problema che hai davanti: prima capisci quale API ti serve (1, 2, 3), poi come passarci dal vecchio (4), poi come usarla da un assistente di codice (5), come reggerne limiti e costi (6), come comportarti verso i suoi crawler (7) e che cosa aspettarti dalla visibilità (8). Prezzi, limiti e nomi dei modelli hanno una data: controllali sulla documentazione ufficiale prima di dimensionare un servizio.
Che cosa sai fare adesso
Sai separare ciò che Perplexity documenta da ciò che circola come tecnica, sai misurare le visite del crawler e la recuperabilità delle tue pagine con un margine d'errore dichiarato, sai che con venti domande, nell'ipotesi di una probabilità vera di 0,5, due sondaggi consecutivi differiscono di almeno due domande quasi due volte su tre anche senza che nulla sia cambiato, e sai che il solo prerequisito documentato è non bloccare PerplexityBot. Il resto non lo prometto: lo misuri.
← Articolo 7: PerplexityBot e robots.txt Torna all'articolo 1: la mappa →
Domande frequenti
Come mi faccio citare da Perplexity?
L'unico prerequisito documentato è non bloccare PerplexityBot. Sui criteri di selezione delle fonti non esiste documentazione ufficiale che io abbia trovato: le pratiche come risposte in apertura e date visibili sono ragionevoli ma non dimostrate.
Posso misurare quante volte vengo citato?
Non in modo affidabile dall'esterno. Puoi misurare le visite del crawler dai log, i clic da perplexity.ai negli analytics e la recuperabilità delle tue pagine con la Search API, ma nessuna di queste è il numero di citazioni nell'applicazione.
Esistono segnali di ranking confermati per Perplexity?
Non nella documentazione letta. I blog di settore ne elencano, ma non ho aperto fonti primarie che li confermino e per questo non li riporto.
Essere citati porta traffico?
Non è dimostrato dalle fonti che ho letto. Per il tuo sito puoi confrontare nel tempo le visite da perplexity.ai con le conversioni, tenendo presente che la misura sottostima le citazioni non cliccate.
Fonti
- Perplexity, Perplexity Crawlers - scopo dei due agenti, comportamento rispetto a robots.txt, tempi di applicazione, file degli indirizzi; letta per intero il 13 novembre 2026
- Perplexity, Search API: overview - parametri e limiti della richiesta (
query,max_results,country,search_domain_filter), pacchettoperplexityai; letta per intero il 13 novembre 2026 - Perplexity, Pricing - prezzo della Search API, 5,00 dollari ogni mille richieste e 1,00 con la ricerca fast; letta per intero il 13 novembre 2026
- Registro PyPI, pacchetto perplexityai - versione più recente, 0.46.1, letta il 13 novembre 2026 dall'interfaccia JSON del registro
Commenti
Caricamento commenti...
Accedi per commentare