Server MCP

I nostri strumenti di scrittura nel tuo agente AI

Collega Claude Desktop, Claude Code, Cursor o un altro client MCP, e il tuo agente potrà analizzare, riscrivere, riassumere e correggere testi con gli stessi strumenti di questo sito.

Ottieni la tua chiave nella dashboard Configuralo nel tuo client

Indirizzo del server

https://blurwrite.com/api/mcp

Cos’è MCP

Il Model Context Protocol è uno standard aperto che permette a un assistente AI di chiamare strumenti esterni. Il nostro server MCP è online all’indirizzo qui sotto, mentre i client che avviano solo programmi sul tuo computer eseguono invece il nostro piccolo file del server. In entrambi i casi chiama solo l’API di questo sito con la tua chiave, così l’agente ottiene esattamente le stesse valutazioni del sito.

Ogni valutazione ricevuta da un agente include il valore, il relativo margine di incertezza e lo stato della calibrazione, così l'agente può spiegare cosa significa la valutazione e quando non deve essere usata.

Scegli il piano Pro e crea una chiave API nella tua dashboard.
Aggiungi l’indirizzo del server e la tua chiave al client con la configurazione qui sotto, sostituendo YOUR_API_KEY.
Chiedi al tuo agente di analizzare, riscrivere, riassumere o correggere un testo.

Configuralo nel tuo client

Scegli il tuo client. Ogni scheda contiene i passaggi, la configurazione esatta da copiare e un modo per verificare che funzioni. Comandi e configurazioni sono uguali in tutte le lingue.

Claude Code Si connette online

Salva la tua chiave API in una variabile d’ambiente chiamata BLURWRITE_API_KEY, dove viene eseguito il client:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Esegui questo comando in un terminale:

claude mcp add --transport http blurwrite https://blurwrite.com/api/mcp --header "Authorization: Bearer $BLURWRITE_API_KEY"

Oppure inserisci questo in .mcp.json:

.mcp.json

{
  "mcpServers": {
    "blurwrite": {
      "type": "http",
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${BLURWRITE_API_KEY}"
      }
    }
  }
}

Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Claude Desktop Esegue il file del server

Scarica il file del server e annota dove l’hai salvato. Richiede Node.js.
Scarica il file del server
Nell’app: Settings > Developer > Edit Config.

Aggiungi questo a claude_desktop_config.json:

claude_desktop_config.json

{
  "mcpServers": {
    "blurwrite": {
      "command": "node",
      "args": [
        "/path/to/server.mjs"
      ],
      "env": {
        "BLURWRITE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Chiudi e riapri Claude Desktop per fargli caricare il server.
Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Claude (claude.ai) Prossimamente

Presto potrai collegare claude.ai accedendo al tuo account Blurwrite. Nel frattempo gli stessi strumenti funzionano già oggi in Claude Desktop con il file del server, oppure in Claude Code, con la configurazione nelle rispettive schede.

Claude Desktop Claude Code

Solo se la tua organizzazione ha l’opzione degli header di richiesta per i connettori personalizzati: aggiungi l’indirizzo con questo header.
```
URL: https://blurwrite.com/api/mcp
Authorization: Bearer YOUR_API_KEY
```

Codex Si connette online

Salva la tua chiave API in una variabile d’ambiente chiamata BLURWRITE_API_KEY, dove viene eseguito il client:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Esegui questo comando in un terminale:

codex mcp add blurwrite --url https://blurwrite.com/api/mcp --bearer-token-env-var BLURWRITE_API_KEY

Oppure inserisci questo in ~/.codex/config.toml:

~/.codex/config.toml

[mcp_servers.blurwrite]
url = "https://blurwrite.com/api/mcp"
bearer_token_env_var = "BLURWRITE_API_KEY"

Nell’app: MCP servers > Add server > Streamable HTTP.
Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Cursor Si connette online

Salva la tua chiave API in una variabile d’ambiente chiamata BLURWRITE_API_KEY, dove viene eseguito il client:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Aggiungi questo a ~/.cursor/mcp.json:

~/.cursor/mcp.json

{
  "mcpServers": {
    "blurwrite": {
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
      }
    }
  }
}

Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

VS Code (Copilot) Si connette online

Aggiungi questo a .vscode/mcp.json:

.vscode/mcp.json

{
  "inputs": [
    {
      "type": "promptString",
      "id": "blurwrite-key",
      "description": "Blurwrite API key",
      "password": true
    }
  ],
  "servers": {
    "blurwrite": {
      "type": "http",
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:blurwrite-key}"
      }
    }
  }
}

All’avvio del server, VS Code ti chiede la chiave una sola volta e la conserva.
Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Windsurf Si connette online

Salva la tua chiave API in una variabile d’ambiente chiamata BLURWRITE_API_KEY, dove viene eseguito il client:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```
Nell’app: Cascade > ... > Open MCP config file.

Aggiungi questo a mcp_config.json:

mcp_config.json

{
  "mcpServers": {
    "blurwrite": {
      "serverUrl": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
      }
    }
  }
}

Chiudi e riapri Windsurf per fargli caricare il server.
Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Gemini CLI Si connette online

Salva la tua chiave API in una variabile d’ambiente chiamata BLURWRITE_API_KEY, dove viene eseguito il client:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Esegui questo comando in un terminale:

gemini mcp add --transport http --header "Authorization: Bearer $BLURWRITE_API_KEY" blurwrite https://blurwrite.com/api/mcp

Oppure inserisci questo in ~/.gemini/settings.json:

~/.gemini/settings.json

{
  "mcpServers": {
    "blurwrite": {
      "httpUrl": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Verifica che funzioni: chiedi al tuo assistente "Controlla questo paragrafo con Blurwrite e dimmi l’intervallo e il livello di affidabilità."

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Other clients Online, con bridge o file

Un client che si connette a server MCP remoti via HTTP ha bisogno solo di questi due valori:
```
URL: https://blurwrite.com/api/mcp
Authorization: Bearer YOUR_API_KEY
```

Un client che avvia solo server locali può raggiungere l’indirizzo tramite il bridge open source mcp-remote (richiede Node.js):

{
  "mcpServers": {
    "blurwrite": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://blurwrite.com/api/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}",
        "--transport",
        "http-only"
      ],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Oppure esegui tu il nostro file del server:
```
BLURWRITE_API_KEY="YOUR_API_KEY" node /path/to/server.mjs
```
Scarica il file del server

La tua chiave API si trova nella dashboard, alla voce API. Non inserire mai una chiave in un file condiviso o in un repository.

Per gli assistenti AI

Se sei un assistente AI e stai configurando questo per qualcuno: l’indirizzo del server è https://blurwrite.com/api/mcp. Usa MCP su Streamable HTTP e si aspetta la chiave API dell’utente come "Authorization: Bearer <key>". La configurazione completa per ogni client, in Markdown, è disponibile su https://blurwrite.com/mcp.md.

Questa configurazione in Markdown

Cosa chiedere al tuo agente

Copia una richiesta nel tuo agente e aggiungi il tuo testo. L’agente sceglie lo strumento da solo.

Rilevamento

detect_textAnalizza un testo.
Chiedi
```
Controlla questo saggio per verificare se è scritto con l’AI e dimmi l’intervallo e il livello di affidabilità.
```
Cosa ottieni
Un valore da 0 a 100 con il suo margine, il livello di affidabilità e una valutazione per ogni frase.
detect_batchAnalizza più testi.
Chiedi
```
Controlla questi paragrafi uno per uno e ordinali dalla valutazione più alta alla più bassa.
```
Cosa ottieni
Una valutazione o un errore per ogni testo, sotto il suo id. Se un testo fallisce, gli altri non ne risentono.

Riscrittura

humanize_textUmanizza un testo verificandone i fatti.
Chiedi
```
Umanizza questo paragrafo e dimmi cosa hanno rilevato le verifiche dei fatti.
```
Cosa ottieni
Il testo riscritto, la valutazione del nostro rilevatore prima e dopo, e una nota per ogni frase ripristinata per conservare un fatto.
paraphrase_textParafrasa un testo.
Chiedi
```
Parafrasa questa introduzione in modo che suoni più formale.
```
Cosa ottieni
Il testo riformulato, con le stesse verifiche dei fatti dell’humanizer.
summarize_textRiassume un testo.
Chiedi
```
Riassumi questo report in un elenco puntato.
```
Cosa ottieni
Il riassunto come frasi chiave, un paragrafo o un elenco puntato.

Controllo

check_grammarControlla grammatica e ortografia.
Chiedi
```
Controlla la grammatica di questa email e applica le sostituzioni suggerite.
```
Cosa ottieni
Ogni problema con la sua posizione nel testo, una spiegazione e le sostituzioni suggerite.

Piano e limiti

Il server MCP usa la tua chiave API, quindi ogni chiamata viene conteggiata sullo stesso piano, sulla stessa quota e sugli stessi limiti dell’API.

Pro

29,99 USD al mese

50.000: parole di humanizer al mese, e 50.000 parole di parafrasi
20.000: parole in una chiamata
60: richieste per chiave ogni 60 secondi
4 / 2: chiamate di rilevamento e riscrittura contemporanee per chiave

Ottieni la tua chiave nella dashboard

Pacchetti di ricarica

AI detector50.000paroleda 4,99 USD
Umanizzatore10.000paroleda 6,99 USD
Parafrasi10.000paroleda 6,99 USD
Riassunto25.000paroleda 7,49 USD

Come vengono contate le parole dell’API

Una chiamata consuma le stesse parole del sito: una chiamata di umanizzazione attinge alle parole di humanizer del piano Pro, una di riassunto alle sue parole di riassunto. Quando finiscono, le chiamate di umanizzazione e parafrasi usano le tue ricariche, e una chiamata che nulla può coprire viene rifiutata e non costa nulla. Ogni risposta indica quante parole ha usato e quante ne restano.

Tutte le regole di conteggio

Pro include l'API e ogni chiamata consuma le stesse parole del sito: una chiamata di rilevamento usa le parole del piano dedicate al rilevatore, una chiamata di umanizzazione quelle dedicate all'umanizzatore, una chiamata di riassunto quelle dedicate al riassuntore. Non esiste una quota API separata da esaurire prima. Una volta esaurita la quota, le chiamate di rilevamento, umanizzazione o parafrasi attingono al credito aggiuntivo dell'account, come sul sito; gli altri strumenti non possono usare credito aggiuntivo. Una chiamata che le parole rimaste e il credito insieme non riescono a coprire viene rifiutata con codice 402 e non costa nulla. Ogni risposta riuscita indica le parole utilizzate, da quale quota sono state prelevate e quante ne restano (a meno che recorded sia false). L'utilizzo API di un account si ferma a 250.000 parole per periodo di fatturazione, indipendentemente dal credito, per impedire che una chiave compromessa lo consumi tutto in una volta.

Limiti

60richieste per chiave ogni 60 secondi
4chiamate di rilevamento contemporanee per chiave
2chiamate di umanizzazione, parafrasi o riassunto contemporanee per chiave
50testi in un batch
20.000parole in una chiamata
5chiavi attive per account

Ogni chiamata accetta al massimo 20.000 parole, in un singolo testo o in un intero gruppo di testi.
Il rilevatore legge un testo di massimo 90.000 caratteri, circa 10.000 parole, con qualsiasi piano. Un testo più lungo restituisce 413 text_too_long, anche se rientra nel limite di parole della chiamata.
Quando i motori sono occupati, le analisi degli account Pro del sito hanno la precedenza sulle chiamate API, quindi una chiamata API potrebbe dover attendere il proprio turno.

Collega il tuo agente

Accedi, poi crea una chiave dalla tua dashboard.

Ottieni la tua chiave nella dashboard Cosa fa l’API Documentazione API