Risposta diretta. Perplexity pubblica un server MCP che porta la ricerca web dentro l'assistente di codice che già usi, e la documentazione ufficiale consiglia di collegarti a quello remoto, https://api.perplexity.ai/mcp, con l'accesso tramite account (OAuth) oppure con una chiave API passata come Authorization: Bearer. In alternativa esiste il pacchetto locale @perplexity-ai/mcp-server, da avviare con npx -y: serve se il client parla solo stdio o se vuoi fissare una versione. I quattro strumenti sono perplexity_search, perplexity_ask, perplexity_reason e perplexity_research. Il costo nascosto: è l'assistente, non tu, a decidere quando chiamarli, e ogni chiamata si fattura alla chiave o all'organizzazione con cui sei collegato.
Remoto o locale: la scelta che decide chi paga e chi aggiorna
Il server remoto lo ospita Perplexity: non installi nulla, non aggiorni nulla, e funziona con qualunque client che supporti server MCP remoti. Al primo uso il client apre il browser, accedi con il tuo account, scegli l'organizzazione API a cui addebitare le chiamate e approvi la connessione. La pagina precisa due limiti utili: la connessione può solo chiamare l'API per conto di quell'organizzazione (non può creare chiavi, vedere i saldi o gestire l'organizzazione) e devi essere amministratore di un'organizzazione API in grado di pagare l'utilizzo.
Il server locale è lo stesso programma, a sorgente aperto, che gira sulla tua macchina su stdio. Lo scegli quando il client supporta solo stdio oppure quando vuoi fissare la versione, e in cambio la chiave API vive nell'ambiente del processo che avvia il client. La documentazione avverte che i due server vogliono esporre gli stessi strumenti, ma trasporto, autenticazione, tempi di rilascio e comportamento del client possono differire: dopo l'installazione controlla sempre l'elenco degli strumenti che il client mostra davvero.
Installazione, client per client
I comandi e le configurazioni di questa sezione sono quelli della pagina ufficiale. I comandi del client (claude ...) non li ho eseguiti: non ho avviato assistenti, non ho una chiave e non mi sono collegato al server. Ciò che ho eseguito davvero sono i file JSON, nella sezione successiva.
Claude Code
Per Claude Code la documentazione raccomanda il server remoto. Dopo il primo comando, il comando /mcp dentro Claude Code avvia l'accesso. La seconda riga installa invece il pacchetto locale: gli apici singoli attorno a PERPLEXITY_API_KEY=${PERPLEXITY_API_KEY} servono a salvare nella configurazione il riferimento alla variabile e non il suo valore.
# Server remoto, accesso con l'account Perplexity (OAuth); poi /mcp dentro Claude Code
claude mcp add --transport http perplexity https://api.perplexity.ai/mcp
# Server locale su stdio; la chiave resta nell'ambiente, il riferimento è fra apici singoli
claude mcp add perplexity --env 'PERPLEXITY_API_KEY=${PERPLEXITY_API_KEY}' -- npx -y @perplexity-ai/mcp-server
# Come plugin, dal repository ufficiale
claude plugin marketplace add perplexityai/modelcontextprotocol
claude plugin install perplexity@perplexity-mcp-server
Se invece vuoi passare la chiave al server remoto, la pagina indica di aggiungere --header "Authorization: Bearer YOUR_API_KEY" al primo comando: in quel caso il valore finisce nella configurazione del client, ed è esattamente il caso che lo script della prossima sezione sa riconoscere nei file JSON. Per la gestione dei server e dei permessi vedi CLI e configurazione e sicurezza e privacy.
Cursor
{
"mcpServers": {
"perplexity": {
"url": "https://api.perplexity.ai/mcp"
}
}
}
Questo è il file ~/.cursor/mcp.json della pagina ufficiale: poi apri le impostazioni di Cursor, voce Tools & MCP, e premi «Connect» accanto a perplexity per accedere. L'esempio locale della stessa pagina scrive la chiave in chiaro dentro env ("your_key_here"): in un file nella tua cartella personale è una scelta tua, in un file che finisce in un repository diventa una chiave pubblicata. Il collegamento di Cursor a basi dati e API è trattato in MCP in Cursor.
VS Code
{
"servers": {
"perplexity": {
"type": "http",
"url": "https://api.perplexity.ai/mcp"
}
}
}
Nel file .vscode/mcp.json dell'area di lavoro: VS Code apre il browser per l'accesso al primo avvio del server. Si noti la differenza di forma rispetto a Cursor: la chiave radice è servers, non mcpServers, e il trasporto si dichiara con "type": "http". Per usare una chiave API la pagina propone un'installazione con inputs, che chiede la chiave all'avvio senza scriverla nel file:
{
"servers": {
"perplexity": {
"type": "http",
"url": "https://api.perplexity.ai/mcp",
"headers": { "Authorization": "Bearer ${input:perplexity-api-key}" }
}
},
"inputs": [
{ "type": "promptString", "id": "perplexity-api-key", "description": "Perplexity API Key", "password": true }
]
}
Il segnaposto ${input:perplexity-api-key} rimanda alla voce promptString con "password": true: VS Code chiede il valore e lo tiene fuori dal file. Questa forma l'ho ricostruita decodificando il collegamento di installazione in un clic della pagina, quindi è quella che Perplexity pubblica. Per il lato Copilot vedi GitHub Copilot, MCP e istruzioni personalizzate.
Prima di fidarti della configurazione: uno script che la controlla
I file .vscode/mcp.json e .mcp.json stanno nel repository, quindi vanno in git, quindi vanno letti da chiunque abbia accesso al codice. Lo script qui sotto legge uno o più file di configurazione, trova i server sotto mcpServers (Claude Code, Cursor, Windsurf) o servers (VS Code) e segnala tre difetti: un URL non https, un valore in env o in Authorization che non è un riferimento a una variabile (${...}), e un pacchetto avviato con npx senza una versione fissata. Funziona senza il prodotto, su file di prova che ho scritto: quattro seguono forme pubblicate da Perplexity, due sono varianti costruite apposta con un difetto, una con una chiave finta e una con http al posto di https.
"""Controlla i file di configurazione MCP: chiavi in chiaro, URL non https, pacchetti senza versione."""
import json
import re
import sys
from pathlib import Path
RIFERIMENTO = re.compile(r"^\$\{[^}]+\}$") # ${VARIABILE} oppure ${input:nome}
def server_di(config):
# Claude Code, Cursor e Windsurf usano "mcpServers"; VS Code usa "servers".
return config.get("mcpServers") or config.get("servers") or {}
def in_chiaro(valore):
pulito = valore.removeprefix("Bearer ").strip()
return bool(pulito) and not RIFERIMENTO.match(pulito)
def controlla(percorso):
problemi, avvisi = [], []
config = json.loads(Path(percorso).read_text(encoding="utf-8"))
for nome, s in server_di(config).items():
url = s.get("url") or s.get("serverUrl")
if url and not url.startswith("https://"):
problemi.append(f"{nome}: URL non https")
for chiave, valore in (s.get("env") or {}).items():
if in_chiaro(valore):
problemi.append(f"{nome}: env {chiave} scritta in chiaro")
if in_chiaro((s.get("headers") or {}).get("Authorization", "")):
problemi.append(f"{nome}: header Authorization in chiaro")
args = s.get("args") or []
if s.get("command") == "npx" and not any(re.search(r"@\d", a) for a in args):
avvisi.append(f"{nome}: pacchetto npx senza versione fissata")
return problemi, avvisi
if __name__ == "__main__":
con_problemi = 0
for percorso in sorted(sys.argv[1:]):
problemi, avvisi = controlla(percorso)
stato = "PROBLEMA" if problemi else "ok"
con_problemi += bool(problemi)
print(f"{Path(percorso).name:36}{stato}")
for m in problemi:
print(f" problema: {m}")
for m in avvisi:
print(f" avviso: {m}")
print(f"file con problemi: {con_problemi} su {len(sys.argv) - 1}")
# Comando: python3 audit_mcp.py prove/*.json
# Output:
# claude-mcp-locale.json ok
# avviso: perplexity: pacchetto npx senza versione fissata
# cursor-locale-chiave-in-chiaro.json PROBLEMA
# problema: perplexity: env PERPLEXITY_API_KEY scritta in chiaro
# cursor-remoto.json ok
# http-senza-tls.json PROBLEMA
# problema: perplexity: URL non https
# vscode-chiave-da-input.json ok
# vscode-remoto.json ok
# file con problemi: 2 su 6
Due file su sei hanno un problema vero: quello con la chiave scritta in env e quello con http://. Il file locale di Claude Code è accettato perché la chiave è un riferimento ${PERPLEXITY_API_KEY}, ma riceve un avviso: npx -y @perplexity-ai/mcp-server scarica ed esegue all'avvio l'ultima versione pubblicata. Fissarla (ad esempio con @1.3.0, l'ultima sul registro npm il 13 novembre 2026 secondo npm view @perplexity-ai/mcp-server version) rende il comportamento ripetibile, ma ti toglie gli aggiornamenti automatici: è un compromesso, non una regola. I limiti dello script: non sa se la variabile esiste davvero (la pagina dice che claude mcp list la segnala come mancante) e non vede ciò che il client salva in proprio dopo un comando con --header.
Quale strumento, quando, e quanto può costare
| Strumento | Dietro le quinte | Usalo per |
|---|---|---|
perplexity_search | Search API; con search_type: "fast" latenza e costo minori | Trovare la pagina ufficiale, il changelog, l'issue |
perplexity_ask | Agent API, livello fast | Una domanda puntuale con fonti |
perplexity_reason | Agent API, livello medium | Problemi a più passaggi e confronti |
perplexity_research | Agent API, livello high | Indagini estese, con citazioni |
La corrispondenza fra strumenti e livelli è quella dichiarata dalla pagina MCP. L'opzione search_type: "fast" di perplexity_search richiede il server locale dalla versione 1.3.0 in poi; quello remoto la supporta già. La regola che applico è usare perplexity_search per trovare l'indirizzo della fonte ufficiale e leggerla, non per ottenere un riassunto, e lasciare gli altri tre strumenti fra quelli che chiedono il mio consenso a ogni chiamata.
Il costo ha una parte che si può calcolare e una che no. Le tariffe degli strumenti sono pubbliche (la Search API costa 5,00 dollari ogni mille richieste, 1,00 con la ricerca fast; dentro l'Agent API una ricerca fast costa 0,001 dollari a invocazione e un fetch_url 0,0005), mentre i token dei tre strumenti dell'Agent API si pagano alle tariffe del modello usato, che dipende dal livello e che Perplexity aggiorna. Lo script calcola solo il limite delle tariffe degli strumenti, con i passi dichiarati oggi dalla pagina «Effort» (versione 2026-11-11.0 dei livelli).
"""Tariffe dei soli strumenti dietro i quattro strumenti MCP (token esclusi).
Prezzi dalla pagina Pricing di Perplexity, consultata il 2026-11-13.
Passi e limiti dalla pagina Effort, versione 2026-11-11.0 dei livelli.
"""
from decimal import Decimal
from fractions import Fraction
MICRO = 1_000_000 # lavoro in micro-dollari: nessun float nel conto
SEARCH_API_STANDARD = 5_000 # 5,00 $ ogni 1000 richieste
SEARCH_API_FAST = 1_000 # 1,00 $ ogni 1000 richieste
WEB_SEARCH_FAST = 1_000 # web_search con search_type "fast": 0,001 $ a invocazione
FETCH_URL = 500 # fetch_url: 0,0005 $ a invocazione
# (strumento MCP, dietro le quinte, massimo di invocazioni documentato, costo massimo di una invocazione)
RIGHE = [
("perplexity_search (standard)", "Search API", 1, SEARCH_API_STANDARD),
("perplexity_search (fast)", "Search API, fast", 1, SEARCH_API_FAST),
("perplexity_ask", "Agent API, fast", 1, WEB_SEARCH_FAST), # fast: 1 passo, chiamate parallele spente
("perplexity_research", "Agent API, high", 40, WEB_SEARCH_FAST), # high: al massimo 40 chiamate
]
def dollari(micro):
return f"{micro / MICRO:.4f}".replace(".", ",")
if __name__ == "__main__":
for nome, dietro, n, unitario in RIGHE:
print(f"{nome:30} {dietro:18} fino a {n:>2} invocazioni -> {dollari(n * unitario)} $ di tariffe")
print("perplexity_reason (medium): 15 passi, nessun tetto di invocazioni documentato")
print(f" se ogni passo fosse una sola ricerca fast: {dollari(15 * WEB_SEARCH_FAST)} $ (stima, non tetto)")
cento_standard = 100 * SEARCH_API_STANDARD
print(f"100 perplexity_search standard: {dollari(cento_standard)} $")
# Secondo calcolo, indipendente: Decimal e Fraction dai prezzi scritti come nella pagina.
per_mille = Decimal("5.00") / 1000
assert Decimal(cento_standard) / MICRO == 100 * per_mille
assert Fraction(40 * WEB_SEARCH_FAST, MICRO) == Fraction(40) * Fraction("1.00") / 1000
print("controllo con Decimal e Fraction: concorda")
# Comando: python3 tetto_costi.py
# Output:
# perplexity_search (standard) Search API fino a 1 invocazioni -> 0,0050 $ di tariffe
# perplexity_search (fast) Search API, fast fino a 1 invocazioni -> 0,0010 $ di tariffe
# perplexity_ask Agent API, fast fino a 1 invocazioni -> 0,0010 $ di tariffe
# perplexity_research Agent API, high fino a 40 invocazioni -> 0,0400 $ di tariffe
# perplexity_reason (medium): 15 passi, nessun tetto di invocazioni documentato
# se ogni passo fosse una sola ricerca fast: 0,0150 $ (stima, non tetto)
# 100 perplexity_search standard: 0,5000 $
# controllo con Decimal e Fraction: concorda
Leggi la riga di perplexity_research: 40 invocazioni è un limite documentato per il livello high (una corsa fa al massimo 40 chiamate di strumenti), quindi 0,04 dollari è un tetto delle tariffe degli strumenti, con i token esclusi. Per medium la pagina indica 15 passi ma non un limite di invocazioni, perché la pagina dichiara spente le chiamate parallele solo per fast e low: per questo la riga è una stima e non un tetto. I calcoli sono in micro-dollari interi e il controllo finale li ripete con Decimal e Fraction partendo dai prezzi scritti come nella pagina.
Verificare che funzioni come credi
Dopo l'installazione fai tre prove, nell'ordine in cui ti dicono cose diverse:
- chiedi all'assistente di elencare gli strumenti MCP disponibili e controlla che compaiano i quattro nomi;
- poni una domanda a cui conosci la risposta e che richiede una fonte recente, per esempio la pagina della documentazione sui limiti di frequenza, e verifica che sia stato chiamato
perplexity_searche non una risposta a memoria; - chiedi un fatto che sai non esistere e osserva se l'assistente lo ammette o lo inventa con tanto di fonte.
L'ultima prova è la più istruttiva: ti dice quanto puoi fidarti dell'assistente quando le fonti non bastano, e il risultato vale per il tuo modello e la tua configurazione, non in generale. Se qualcosa non va, i sospetti ricorrenti sono tre: la variabile PERPLEXITY_API_KEY non è visibile al processo che avvia il client (succede facilmente se lo avvii da un lanciatore grafico invece che da un terminale), npx non è nel percorso del client, oppure il server remoto aspetta un consenso OAuth che non hai ancora completato.
Il web entra nel contesto dell'assistente
Un assistente con accesso al terminale e ai file che legge risultati di ricerca sta mescolando testo non fidato con istruzioni fidate. Brave ha descritto il problema nel browser Comet di Perplexity il 20 agosto 2025: quando l'utente chiedeva di riassumere una pagina, parte del contenuto andava al modello senza distinguere le istruzioni dell'utente dal testo della pagina, e istruzioni nascoste in quel testo venivano eseguite. Il caso è un browser, non MCP, e la superficie è diversa, ma le contromisure che Brave propone valgono per qualunque agente che legge il web:
- il contenuto delle pagine va trattato come non fidato, separato dalle richieste dell'utente;
- le azioni che il modello propone vanno controllate rispetto a ciò che l'utente ha chiesto;
- le operazioni sensibili richiedono un'interazione esplicita, per esempio una conferma prima di inviare un'email.
Per un assistente di codice questo si traduce in approvazione manuale per i comandi di shell, per le scritture fuori dalla cartella di lavoro e per l'installazione di pacchetti, e in una regola semplice: un comando suggerito da un risultato di ricerca lo leggi tu prima di farlo eseguire. Nessun filtro automatico sul testo sostituisce questa lettura.
Che cosa esce dal tuo computer
La domanda che l'assistente invia contiene ciò che gli hai scritto o ciò che ha letto: nomi di classi, messaggi d'errore, a volte frammenti di codice. La pagina «Privacy & Security» dell'API dice che, secondo i termini del servizio, Perplexity non usa il contenuto dei clienti per addestrare modelli generativi; dice anche che la Zero Data Retention non è predefinita (è disponibile solo a clienti idonei, con un accordo scritto, e non tutti i modelli la supportano) e che per i modelli di terzi valgono anche le condizioni dei rispettivi fornitori, alcuni dei quali richiedono una conservazione limitata. Raccoglie inoltre metadati d'uso come numero di richieste e di token, modello, orari e durata. Di conseguenza la regola minima è scritta: niente segreti e niente dati personali nelle domande.
Scenario dichiarato: l'aggiornamento di una dipendenza
Ipotesi: devi passare una libreria a una nuova versione maggiore e chiedi all'assistente di trovare con perplexity_search la pagina delle modifiche incompatibili, riportando l'URL e la riga esatta prima di toccare il codice. Cosa va storto: l'assistente applica una correzione letta su un blog e riferita a un'altra versione. Regola: la modifica parte solo se fra le fonti citate c'è il changelog ufficiale e se i test del progetto passano.
Scenario dichiarato: un piccolo team con un file condiviso
Ipotesi: tre sviluppatori condividono un repository con un .vscode/mcp.json e uno di loro, per fare presto, ci scrive la chiave nell'intestazione. Cosa va storto: la chiave entra in git e dalla cronologia non esce più senza rigenerarla. Rimedio: il file nel repository contiene solo l'URL o il riferimento ${input:...}, ciascuno accede con il proprio account o con la propria chiave, e lo script di questa pagina gira prima di ogni commit.
Che cosa sai fare adesso
Sai scegliere fra server remoto e locale e dire chi paga e chi aggiorna, sai configurare Claude Code, Cursor e VS Code senza scrivere la chiave in un file, sai controllare i file di configurazione con uno script, e sai stimare il costo delle sole tariffe degli strumenti per ciascuno dei quattro strumenti. Non sai ancora quanto ti costeranno i token e come reggere i 429: è il tema dell'articolo 6.
← Articolo 4: da Sonar all'Agent API Articolo 6: costi, QPS e 429 →
Domande frequenti
Qual è il server MCP ufficiale di Perplexity?
Il server remoto https://api.perplexity.ai/mcp, consigliato dalla documentazione, oppure il pacchetto locale @perplexity-ai/mcp-server avviabile con npx -y. Espongono perplexity_search, perplexity_ask, perplexity_reason e perplexity_research.
Come lo installo in Claude Code?
Con claude mcp add --transport http perplexity https://api.perplexity.ai/mcp per il server remoto, poi /mcp per accedere. Per il locale: claude mcp add perplexity --env 'PERPLEXITY_API_KEY=${PERPLEXITY_API_KEY}' -- npx -y @perplexity-ai/mcp-server. Esiste anche un plugin.
Quale strumento costa meno?
perplexity_search, che usa la Search API: 5,00 dollari ogni mille richieste, 1,00 con search_type fast. Gli altri tre usano l'Agent API ai livelli fast, medium e high: token alle tariffe del modello più le tariffe degli strumenti.
È sicuro lasciare che l'assistente chiami la ricerca da solo?
Il rischio principale è che testo web non fidato influenzi le azioni dell'assistente. Mantieni l'approvazione manuale per comandi e scritture, e non inserire segreti o dati personali nelle domande.
Fonti
- Perplexity, Perplexity API MCP Server - server remoto e locale, accesso, comandi per client, i quattro strumenti e il livello di effort di ciascuno; letta per intero il 13 novembre 2026
- Perplexity, Pricing - tariffe della Search API e degli strumenti dell'Agent API; letta per intero il 13 novembre 2026
- Perplexity, Agent API: Effort - passi e limite di chiamate dei livelli fast, medium e high (versione 2026-11-11.0); sezioni sui valori dei livelli lette il 13 novembre 2026
- Perplexity, Privacy & Security - addestramento, Zero Data Retention, modelli di terzi, metadati d'uso; letta per intero il 13 novembre 2026
- Brave, Indirect Prompt Injection in Perplexity Comet - descrizione del problema e contromisure proposte (pubblicato il 20 agosto 2025); sezioni sul problema e sulle mitigazioni lette il 13 novembre 2026
- Comando
npm view @perplexity-ai/mcp-server versionsul registro npm - versione più recente del pacchetto locale, 1.3.0, eseguito il 13 novembre 2026
Commenti
Caricamento commenti...
Accedi per commentare