Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
firecrawl-mcp-server — Server MCP che fornisce capacità di web scraping, crawling e ricerca per agenti AI. Supporta l'estrazione di dati strutturati, la navigazione interattiva e la ricerca approfondita tramite un'API unificata. | Kitploit
Strumenti/GitHubGitHub/firecrawl/firecrawl-mcp-server
Raccolta InformazioniUtilità e FrameworkCrawler
GitHubfirecrawl/firecrawl-mcp-server

firecrawl-mcp-server

Server MCP che fornisce capacità di web scraping, crawling e ricerca per agenti AI. Supporta l'estrazione di dati strutturati, la navigazione interattiva e la ricerca approfondita tramite un'API unificata.

Vedi Repository

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
Sito web
7.2k8431 giorno faRevisionato da Kitploit

Firecrawl MCP Server

Un server Model Context Protocol (MCP) che porta Firecrawl agli agenti AI compatibili con MCP — cerca, raspa e interagisci con il web live per un contesto pulito e pronto per gli agenti.

Un grande ringraziamento a @vrknetha e @knacklabs per l'implementazione iniziale!

Funzionalità

  • Cerca sul web e ottieni il contenuto completo delle pagine
  • Raspa qualsiasi URL in dati puliti e strutturati
  • Interagisci con le pagine — clicca, naviga e opera
  • Ricerca approfondita con agente autonomo
  • Tentativi automatici e limitazione delle richieste
  • Supporto cloud e self-hosted
  • Supporto SSE

Gioca con il nostro MCP Server sul playground di MCP.so o su Klavis AI.

Installazione

MCP hostato (livello gratuito senza chiave)

Connettiti al server remoto hostato senza alcuna configurazione:``` https://mcp.firecrawl.dev/v2/mcp

root@kitploit:~
Sul livello gratuito senza chiave, `scrape`, `search` e `interact` funzionano senza una chiave API (limitati). Altri strumenti come `crawl`, `map`, `agent` e `extract` necessitano ancora di una chiave. Preferisci una chiave API o OAuth quando l'utente può registrarsi. Sblocca l'intero set di strumenti e limiti più alti. Con una chiave, usa:```
https://mcp.firecrawl.dev/{FIRECRAWL_API_KEY}/v2/mcp

Consulta la documentazione del server MCP e la guida all'onboarding dell'agente per i dettagli di configurazione.

Esecuzione con npx```bash

env FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp

root@kitploit:~
### Installazione Manuale```bash
npm install -g firecrawl-mcp

Esecuzione su Cursor

Configurazione di Cursor 🖥️ Nota: richiede Cursor versione 0.45.6+ Per le istruzioni di configurazione più aggiornate, consultare la documentazione ufficiale di Cursor sulla configurazione dei server MCP: Cursor MCP Server Configuration Guide

Per configurare Firecrawl MCP in Cursor v0.48.6

  1. Apri le Impostazioni di Cursor
  2. Vai su Funzionalità > Server MCP
  3. Clicca su '+ Aggiungi nuovo server MCP globale'
  4. Inserisci il seguente codice: ```json { "mcpServers": { "firecrawl-mcp": { "command": "npx", "args": ["-y", "firecrawl-mcp"], "env": { "FIRECRAWL_API_KEY": "YOUR-API-KEY" } } } }
    root@kitploit:~

Per configurare Firecrawl MCP in Cursor v0.45.6

  1. Apri le Impostazioni di Cursor
  2. Vai a Funzionalità > Server MCP
  3. Clicca "+ Aggiungi Nuovo Server MCP"
  4. Inserisci quanto segue:
    • Nome: "firecrawl-mcp" (o il nome che preferisci)
    • Tipo: "command"
    • Comando: env FIRECRAWL_API_KEY=la-tua-chiave-api npx -y firecrawl-mcp

Se usi Windows e hai problemi, prova cmd /c "set FIRECRAWL_API_KEY=la-tua-chiave-api && npx -y firecrawl-mcp"

Sostituisci la-tua-chiave-api con la tua chiave API Firecrawl. Se non ne hai ancora una, puoi creare un account e ottenerla da https://www.firecrawl.dev/app/api-keys

Dopo aver aggiunto, aggiorna l'elenco dei server MCP per vedere i nuovi strumenti. L'Agente Composer utilizzerà automaticamente Firecrawl MCP quando opportuno, ma puoi richiederlo esplicitamente descrivendo le tue esigenze di scraping web. Accedi al Composer tramite Comando+L (Mac), seleziona "Agente" accanto al pulsante di invio e inserisci la tua richiesta.

Esecuzione su Windsurf

Aggiungi questo al tuo ./codeium/windsurf/model_config.json:```json { "mcpServers": { "mcp-server-firecrawl": { "command": "npx", "args": ["-y", "firecrawl-mcp"], "env": { "FIRECRAWL_API_KEY": "YOUR_API_KEY" } } } }

root@kitploit:~
### Esecuzione con Streamable HTTP in Modalità Locale

Per eseguire il server utilizzando Streamable HTTP in locale invece del trasporto stdio predefinito:```bash
env HTTP_STREAMABLE_SERVER=true FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp

Installazione tramite Smithery (Legacy)

Per installare automaticamente Firecrawl per Claude Desktop tramite Smithery:```bash npx -y @smithery/cli install @mendableai/mcp-server-firecrawl --client claude

root@kitploit:~
### Esecuzione su VS Code

Per un'installazione con un clic, fai clic su uno dei pulsanti di installazione qui sotto...

[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D&quality=insiders)

Per l'installazione manuale, aggiungi il seguente blocco JSON al file User Settings (JSON) in VS Code. Puoi farlo premendo `Ctrl + Shift + P` e digitando `Preferences: Open User Settings (JSON)`.```json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "apiKey",
        "description": "Firecrawl API Key",
        "password": true
      }
    ],
    "servers": {
      "firecrawl": {
        "command": "npx",
        "args": ["-y", "firecrawl-mcp"],
        "env": {
          "FIRECRAWL_API_KEY": "${input:apiKey}"
        }
      }
    }
  }
}

Opzionalmente, puoi aggiungerlo a un file chiamato .vscode/mcp.json nella tua area di lavoro. Questo ti permetterà di condividere la configurazione con altri:```json { "inputs": [ { "type": "promptString", "id": "apiKey", "description": "Firecrawl API Key", "password": true } ], "servers": { "firecrawl": { "command": "npx", "args": ["-y", "firecrawl-mcp"], "env": { "FIRECRAWL_API_KEY": "${input:apiKey}" } } } }

root@kitploit:~
## Configurazione

### Variabili d'ambiente

#### Richieste per l'API Cloud

- `FIRECRAWL_API_KEY`: La tua chiave API Firecrawl
  - Richiesta quando si utilizza l'API cloud (predefinita)
  - Opzionale quando si utilizza un'istanza self-hosted con `FIRECRAWL_API_URL`
- `FIRECRAWL_API_URL` (Opzionale): Endpoint API personalizzato per istanze self-hosted
  - Esempio: `https://firecrawl.your-domain.com`
  - Se non fornito, verrà utilizzata l'API cloud (richiede la chiave API)

#### MCP OAuth (token di accesso Bearer)

Firecrawl hosted può emettere **token di accesso** OAuth (`fco_…`) tramite il server di autorizzazione su [firecrawl.dev](https://firecrawl.dev). Questo server MCP inoltra qualsiasi credenziale risolta all'API Firecrawl come `Authorization: Bearer …`.

- **Trasporti di stream HTTP** (`CLOUD_SERVICE=true`, `HTTP_STREAMABLE_SERVER=true` o `SSE_LOCAL=true`): I client dovrebbero inviare `Authorization: Bearer <fco_access_token>` nelle richieste MCP. Un token di accesso OAuth ha la precedenza su `x-firecrawl-api-key` / `x-api-key` quando entrambi sono presenti.
- **stdio:** Usa `FIRECRAWL_OAUTH_TOKEN` per un token di accesso statico, oppure continua a usare `FIRECRAWL_API_KEY` per una chiave API.

Usa solo token di **accesso** (`fco_…`). I token di aggiornamento (`fcr_…`) devono essere scambiati presso l'endpoint del token, non passati all'API di scraping/ricerca.

### Esempi di configurazione

Per l'utilizzo dell'API cloud:```bash
export FIRECRAWL_API_KEY=your-api-key

Per istanza self-hosted:```bash

Required for self-hosted

export FIRECRAWL_API_URL=https://firecrawl.your-domain.com

Optional authentication for self-hosted

export FIRECRAWL_API_KEY=your-api-key # If your instance requires auth

root@kitploit:~
### Utilizzo con Claude Desktop

Aggiungi questo al tuo `claude_desktop_config.json`:```json
{
  "mcpServers": {
    "mcp-server-firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Come scegliere uno strumento

Usa questa guida per selezionare lo strumento giusto per il tuo compito:

  • Se conosci l'URL esatto che vuoi: usa scrape (con formato JSON per dati strutturati)
  • Se hai più URL noti: chiama scrape per ogni URL. Se hai bisogno specificamente di un'operazione API unica in blocco, usa l'endpoint batch dell'API Firecrawl al di fuori di MCP.
  • Se devi scoprire URL su un sito: usa map
  • Se vuoi cercare informazioni sul web: usa search
  • Se hai bisogno di una ricerca complessa su più fonti sconosciute: usa agent
  • Se vuoi analizzare un intero sito o sezione: usa crawl (con limiti!)
  • Se hai bisogno di automazione interattiva del browser (clicca, digita, naviga): usa interact con un URL per una pagina nuova, oppure scrape + interact quando hai già estratto la pagina o hai bisogno di un controllo più stretto sull'estrazione

Tabella di riferimento rapido

Guida alla scelta del formato

Quando usi scrape, scegli il formato giusto:

  • Formato JSON (consigliato per la maggior parte dei casi): Usalo quando hai bisogno di dati specifici da una pagina. Definisci uno schema basato su ciò che devi estrarre. Questo mantiene le risposte piccole ed evita il sovraccarico del contesto.
  • Formato Markdown (usalo con parsimonia): Solo quando hai realmente bisogno dell'intero contenuto della pagina, ad esempio per leggere un intero articolo da riassumere o analizzare la struttura della pagina.

Strumenti Disponibili

1. Strumento Scrape (firecrawl_scrape)

Estrai contenuto da un singolo URL con opzioni avanzate.

Ideale per:

  • Estrazione del contenuto di una singola pagina, quando sai esattamente quale pagina contiene le informazioni.

Sconsigliato per:

  • Estrarre contenuto da più pagine (usa chiamate scrape ripetute per URL noti, oppure map + scrape per scoprire prima gli URL, o crawl per il contenuto completo della pagina)
  • Quando non sei sicuro di quale pagina contenga le informazioni (usa search)

Errori comuni:

  • Passare un elenco di URL a una singola chiamata scrape. Chiama scrape una volta per URL in MCP. Se hai bisogno specificamente di un'operazione API unica in blocco, usa l'endpoint batch dell'API Firecrawl al di fuori di MCP.
  • Usare il formato markdown di default (usa il formato JSON per estrarre solo ciò che ti serve).

Scegliere il formato giusto:

  • Formato JSON (preferito): Per la maggior parte dei casi, usa il formato JSON con uno schema per estrarre solo i dati specifici necessari. Questo mantiene le risposte mirate e previene il sovraccarico del contesto.
  • Formato Markdown: Solo quando il compito richiede realmente il contenuto completo della pagina (ad esempio, riassumere un intero articolo, analizzare la struttura della pagina).

Esempio di prompt:

"Ottieni i dettagli del prodotto da https://example.com/product."

Esempio di utilizzo (formato JSON - preferito):```json { "name": "firecrawl_scrape", "arguments": { "url": "https://example.com/product", "formats": [ { "type": "json", "prompt": "Extract the product information", "schema": { "type": "object", "properties": { "name": { "type": "string" }, "price": { "type": "number" }, "description": { "type": "string" } }, "required": ["name", "price"] } } ] } }

root@kitploit:~
**Esempio di utilizzo (formato markdown - quando è necessario il contenuto completo):**```json
{
  "name": "firecrawl_scrape",
  "arguments": {
    "url": "https://example.com/article",
    "formats": ["markdown"],
    "onlyMainContent": true
  }
}

Esempio di utilizzo (formato di branding - estrarre l'identità del marchio):```json { "name": "firecrawl_scrape", "arguments": { "url": "https://example.com", "formats": ["branding"] } }

root@kitploit:~
**Formato del branding:** Estrae un'identità di marca completa (colori, font, tipografia, spaziatura, logo, componenti UI) per analisi di design o replica di stili.
**Privacy:** Imposta `redactPII: true` per restituire contenuti con informazioni personali identificabili oscurate.

**Restituisce:**

- Dati strutturati JSON, markdown, profilo del branding o altri formati come specificato.

### 2. Strumento Map (`firecrawl_map`)

Mappa un sito web per scoprire tutti gli URL indicizzati sul sito.

**Ideale per:**

- Scoprire gli URL su un sito web prima di decidere cosa raschiare
- Trovare sezioni specifiche di un sito web

**Non raccomandato per:**

- Quando già sai quale URL specifico ti serve (usa scrape)
- Quando hai bisogno del contenuto delle pagine (usa scrape dopo la mappatura)

**Errori comuni:**

- Usare crawl per scoprire URL invece di map

**Esempio di prompt:**

> "Elenca tutti gli URL su example.com."

**Esempio di utilizzo:**```json
{
  "name": "firecrawl_map",
  "arguments": {
    "url": "https://example.com"
  }
}

Restituisce:

  • Array di URL trovati sul sito

3. Strumento di ricerca (firecrawl_search)

Cerca nel web e, opzionalmente, estrai il contenuto dai risultati di ricerca.

Ideale per:

  • Trovare informazioni specifiche su più siti web, quando non sai quale sito contiene l'informazione.
  • Quando hai bisogno del contenuto più pertinente per una query

Non consigliato per:

  • Quando già sai quale sito web analizzare (usa scrape)
  • Quando hai bisogno di una copertura completa di un singolo sito web (usa map o crawl)

Errori comuni:

  • Usare crawl o map per domande aperte (usa invece search)

Esempio di utilizzo:```json { "name": "firecrawl_search", "arguments": { "query": "latest AI research papers 2023", "limit": 5, "lang": "en", "country": "us", "scrapeOptions": { "formats": ["markdown"], "onlyMainContent": true, "redactPII": true } } }

root@kitploit:~
**Restituisce:**

- Array di risultati di ricerca (con contenuto opzionale estratto), più un campo `id`. Passa quell'`id` a `firecrawl_search_feedback` dopo aver utilizzato i risultati per rimborsare 1 credito (la ricerca costa 2) e migliorare la qualità della ricerca.

**Esempio di prompt:**

> "Trova gli ultimi articoli di ricerca sull'IA pubblicati nel 2023."

### 3b. Strumento di Feedback per la Ricerca (`firecrawl_search_feedback`)

Invia un feedback strutturato su un risultato precedente di `firecrawl_search`. Il primo feedback per id di ricerca rimborsa 1 credito e migliora la qualità della ricerca di Firecrawl. Idempotente per id di ricerca.

**Chiamalo dopo ogni ricerca che usi effettivamente** (o che non è stata d'aiuto). Un feedback negativo o parziale con `missingContent` è altrettanto prezioso di un buon feedback.

**Rinuncia:** imposta `FIRECRAWL_NO_SEARCH_FEEDBACK=1` (o `FIRECRAWL_DISABLE_SEARCH_FEEDBACK=1`) nell'ambiente all'avvio del server MCP. Lo strumento `firecrawl_search_feedback` non verrà registrato, quindi gli agenti non potranno chiamarlo. Gli amministratori del team possono anche disabilitare il feedback lato server; in tal caso lo strumento è registrato ma restituisce sempre `feedbackErrorCode: "TEAM_OPTED_OUT"`.

**Campo più importante:** `missingContent`. È un array di specifici pezzi di contenuto che l'agente si aspettava di trovare ma non ha trovato. Un inserimento per argomento mancante — questi si aggregano tra i team e ci dicono cosa indicizzare successivamente.

**Limite giornaliero di rimborso (per team, per giorno UTC, default 100 crediti).** Una volta che `creditsRefundedToday` di un team raggiunge `dailyRefundCap`, le successive richieste registrano ancora il feedback ma non rimborsano più crediti. La risposta imposta `dailyCapReached: true`. Gli agenti dovrebbero smettere di chiamare questo strumento per il resto del giorno UTC quando vedono quel flag.

**Esempio di utilizzo:**```json
{
  "name": "firecrawl_search_feedback",
  "arguments": {
    "searchId": "0193f6c5-1234-7890-abcd-1234567890ab",
    "rating": "good",
    "valuableSources": [
      {
        "url": "https://docs.firecrawl.dev/features/search",
        "reason": "Most up-to-date description of /search."
      }
    ],
    "missingContent": [
      {
        "topic": "Pricing for the search endpoint",
        "description": "No pricing tier table for /search specifically."
      },
      { "topic": "Per-team rate limits" }
    ],
    "querySuggestions": "Boost docs.firecrawl.dev for queries that mention 'firecrawl'"
  }
}

Restituisce:

  • { success, feedbackId, creditsRefunded, alreadySubmitted? } JSON.

3c. Strumento di Feedback Generico (firecrawl_feedback)

Invia feedback strutturato per un job endpoint v2 completato tramite /v2/feedback. Usa questo per feedback a livello di endpoint su job scrape, parse, map, o search. Per la qualità dei risultati di ricerca in particolare, preferisci firecrawl_search_feedback perché include indicazioni specifiche per la ricerca.

Mantieni il feedback conciso: usa codici di problema, tag, brevi note, URL, numeri di pagina, e piccoli oggetti di metadati. Non includere output grezzi di scrape/parse.

Rinuncia: imposta FIRECRAWL_NO_ENDPOINT_FEEDBACK=1 (o FIRECRAWL_DISABLE_ENDPOINT_FEEDBACK=1) nell'ambiente quando si avvia il server MCP. Lo strumento firecrawl_feedback non verrà registrato, quindi gli agenti non possono chiamarlo.

Esempio di Utilizzo:```json { "name": "firecrawl_feedback", "arguments": { "endpoint": "scrape", "jobId": "0193f6c5-1234-7890-abcd-1234567890ab", "rating": "partial", "issues": ["missing_markdown"], "tags": ["docs"], "note": "The pricing table was missing from the markdown output.", "url": "https://example.com/pricing", "pageNumbers": [1], "metadata": { "format": "markdown" } } }

root@kitploit:~
**Returns:**

- `{ success, feedbackId, creditsRefunded, creditsRefundedToday?, dailyRefundCap?, dailyCapReached?, alreadySubmitted?, warning? }` JSON.

### 4. Strumento di Crawl (`firecrawl_crawl`)

Avvia un job di crawl, lo interroga fino a raggiungere uno stato terminale e restituisce lo stato/dati finali del crawl.

**Ideale per:**

- Estrarre contenuti da più pagine correlate, quando serve una copertura completa.

**Non consigliato per:**

- Estrarre contenuti da una singola pagina (usa scrape)
- Quando i limiti di token sono un problema (usa map + scrape per un controllo più stretto)
- Quando servono risultati rapidi (il crawl può essere lento)

**Attenzione:** Le risposte del crawl possono essere molto grandi e potrebbero superare i limiti di token. Limita la profondità del crawl e il numero di pagine, oppure usa map + scrape per un controllo più stretto.

**Errori comuni:**

- Impostare limit o maxDiscoveryDepth troppo alti (causa overflow di token)
- Usare il crawl per una singola pagina (usa invece scrape)

**Esempio di Prompt:**

> "Ottieni tutti i post del blog dai primi due livelli di example.com/blog."

**Esempio di Utilizzo:**```json
{
  "name": "firecrawl_crawl",
  "arguments": {
    "url": "https://example.com/blog/*",
    "maxDiscoveryDepth": 2,
    "limit": 100,
    "allowExternalLinks": false,
    "deduplicateSimilarURLs": true
  }
}

Risultato:

  • Stato finale del crawl e dati dopo il polling interno, inclusi id, status, completed, total, creditsUsed, expiresAt, next e data. Usa l'id restituito con firecrawl_check_crawl_status se hai bisogno di ricontrollare il job in seguito.

5. Controlla lo stato del crawl (firecrawl_check_crawl_status)

Controlla lo stato e i risultati di un job di crawl esistente tramite ID.```json { "name": "firecrawl_check_crawl_status", "arguments": { "id": "550e8400-e29b-41d4-a716-446655440000" } }

root@kitploit:~
**Restituisce:**

- La risposta include lo stato del lavoro di crawling:

### 6. Parse Tool (`firecrawl_parse`)

Analizza file locali o riferimenti di upload ospitati con l'endpoint `/v2/parse` di Firecrawl.

**Ideale per:** PDF, documenti Word, fogli di calcolo, file HTML e altri documenti che necessitano di output markdown o JSON strutturato. L'MCP ospitato supporta un flusso in due passaggi (upload-ref); la lettura diretta di file locali richiede un `FIRECRAWL_API_URL` self-hosted.

**Sconsigliato per:** URL remoti (usa scrape), più file in una singola chiamata (chiama parse una volta per file) o azioni solo browser come screenshot e click.

**Flusso MCP ospitato:** L'MCP ospitato non può leggere direttamente il filesystem del chiamante. Chiama `firecrawl_parse` con `filePath` per ricevere un comando di upload a breve durata e `nextToolCall`, carica il file localmente, quindi chiama di nuovo `firecrawl_parse` con l'`uploadRef` restituito. Il conio dell'URL di upload ospitato richiede l'autenticazione Firecrawl o l'idoneità senza chiave. In modalità locale `npx firecrawl-mcp`, l'analisi diretta dei file richiede attualmente un `FIRECRAWL_API_URL` che punti a un'API Firecrawl self-hosted; un server locale semplice con solo chiave API cloud non può leggere e caricare file tramite questo strumento.

**Esempio di utilizzo:**```json
{
  "name": "firecrawl_parse",
  "arguments": {
    "filePath": "/absolute/path/to/document.pdf",
    "formats": ["markdown"],
    "parsers": ["pdf"],
    "zeroDataRetention": true
  }
}

Returns: Contenuto del documento analizzato o istruzioni per il caricamento ospitato con un nextToolCall.

7. Strumento Extract (firecrawl_extract)

Estrae informazioni strutturate dalle pagine web utilizzando le capacità LLM. Supporta sia AI cloud che estrazione LLM self-hosted.

Ideale per:

  • Estrarre dati strutturati specifici come prezzi, nomi, dettagli.

Non consigliato per:

  • Quando hai bisogno del contenuto completo di una pagina (usa scrape)
  • Quando non stai cercando dati strutturati specifici

Argomenti:

  • urls: Array di URL da cui estrarre informazioni
  • prompt: Prompt personalizzato per l'estrazione LLM
  • systemPrompt: Prompt di sistema per guidare l'LLM
  • schema: Schema JSON per l'estrazione di dati strutturati
  • allowExternalLinks: Consenti estrazione da link esterni
  • enableWebSearch: Abilita ricerca web per contesto aggiuntivo
  • includeSubdomains: Includi sottodomini nell'estrazione

Quando si utilizza un'istanza self-hosted, l'estrazione utilizzerà il tuo LLM configurato. Per l'API cloud, utilizza il servizio LLM gestito di Firecrawl. Esempio di Prompt:

"Estrai il nome del prodotto, il prezzo e la descrizione da queste pagine prodotto."

Esempio di Utilizzo:```json { "name": "firecrawl_extract", "arguments": { "urls": ["https://example.com/page1", "https://example.com/page2"], "prompt": "Extract product information including name, price, and description", "systemPrompt": "You are a helpful assistant that extracts product information", "schema": { "type": "object", "properties": { "name": { "type": "string" }, "price": { "type": "number" }, "description": { "type": "string" } }, "required": ["name", "price"] }, "allowExternalLinks": false, "enableWebSearch": false, "includeSubdomains": false } }

root@kitploit:~
**Restituisce:**

- Dati strutturati estratti come definito dal tuo schema```json
{
  "content": [
    {
      "type": "text",
      "text": {
        "name": "Example Product",
        "price": 99.99,
        "description": "This is an example product description"
      }
    }
  ],
  "isError": false
}

8. Strumento Agente (firecrawl_agent)

Agente di ricerca web autonomo. Si tratta di un livello separato di agente IA che naviga autonomamente su Internet, cerca informazioni, esplora pagine ed estrae dati strutturati in base alla tua richiesta.

Come funziona:

L'agente esegue ricerche sul web, segue i collegamenti, legge le pagine e raccoglie dati in modo autonomo. Questa operazione viene eseguita in modo asincrono - restituisce immediatamente un ID job e tu interroghi firecrawl_agent_status per verificare il completamento e ottenere i risultati.

Flusso di lavoro asincrono:

  1. Chiama firecrawl_agent con la tua richiesta/schema → restituisce un ID job
  2. Esegui altro lavoro mentre l'agente ricerca (può richiedere minuti per query complesse)
  3. Interroga firecrawl_agent_status con l'ID job per controllare l'avanzamento
  4. Quando lo stato è "completato", la risposta include i dati estratti

Ideale per:

  • Attività di ricerca complesse dove non conosci gli URL esatti
  • Raccolta di dati da più fonti
  • Trovare informazioni sparse sul web
  • Attività dove puoi fare altro mentre aspetti i risultati

Non consigliato per:

  • Estrazione semplice da una singola pagina di cui conosci l'URL (usa scrape con formato JSON – più veloce ed economico)

Argomenti:

  • prompt: Descrizione in linguaggio naturale dei dati che desideri (obbligatorio, massimo 10.000 caratteri)
  • urls: Array opzionale di URL su cui focalizzare l'agente per pagine specifiche
  • schema: Schema JSON opzionale per output strutturato

Esempio di richiesta:

"Trova i fondatori di Firecrawl e le loro esperienze"

Esempio di utilizzo (avvia l'agente, poi interroga per i risultati):```json { "name": "firecrawl_agent", "arguments": { "prompt": "Find the top 5 AI startups founded in 2024 and their funding amounts", "schema": { "type": "object", "properties": { "startups": { "type": "array", "items": { "type": "object", "properties": { "name": { "type": "string" }, "funding": { "type": "string" }, "founded": { "type": "string" } } } } } } } }

root@kitploit:~
Interroga con `firecrawl_agent_status` utilizzando l'ID del job restituito.

**Esempio di utilizzo (con URL - l'agente si concentra su pagine specifiche):**```json
{
  "name": "firecrawl_agent",
  "arguments": {
    "urls": ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
    "prompt": "Compare the features and pricing information from these pages"
  }
}

Returns:

  • ID del lavoro per il controllo dello stato. Usa firecrawl_agent_status per interrogare i risultati.

9. Controlla lo stato dell'agente (firecrawl_agent_status)

Controlla lo stato di un job dell'agente e recupera i risultati al completamento. Usa questa funzione per interrogare i risultati dopo aver avviato un agente.

Schema di polling: La ricerca dell'agente può richiedere minuti per query complesse. Interroga questo endpoint periodicamente (ad es. ogni 10-30 secondi) fino a quando lo stato è "completato" o "fallito".```json { "name": "firecrawl_agent_status", "arguments": { "id": "550e8400-e29b-41d4-a716-446655440000" } }

root@kitploit:~
**Possible statuses:**

- `processing`: L'agente sta ancora ricercando - controlla più tardi
- `completed`: Ricerca completata - la risposta include i dati estratti
- `failed`: Si è verificato un errore

### 10. Interact Tool (`firecrawl_interact`)

Interagisci con un nuovo URL o con una pagina già aperta da `firecrawl_scrape`.

**Ideale per:** Fare clic, digitare, navigare ed estrarre lo stato da pagine dinamiche senza ripristinare gli strumenti del browser deprecati.

**Opzioni di utilizzo:**

- Passa `url` per raschiare e aprire una pagina per l'interazione in una singola chiamata MCP.
- Passa `scrapeId` per continuare a interagire con una pagina già raschiata.
- Passa esattamente uno tra `url` o `scrapeId`, più uno tra `prompt` o `code`.

**Esempio di utilizzo:**```json
{
  "name": "firecrawl_interact",
  "arguments": {
    "url": "https://example.com",
    "prompt": "Click the pricing link and summarize the visible plans"
  }
}

Restituisce: Risultato dell'interazione e, per la modalità URL, il scrapeId derivato per follow-up o pulizia.

11. Strumento Stop Interact (firecrawl_interact_stop)

Ferma una sessione di interazione per una pagina scrapata quando hai finito di interagire.```json { "name": "firecrawl_interact_stop", "arguments": { "scrapeId": "scrape-id-here" } }

root@kitploit:~
### 12. Strumenti di Ricerca (`firecrawl_research_*`)

Cerca e ispeziona articoli e repository GitHub attraverso gli strumenti di ricerca MCP.

**Strumenti di ricerca disponibili:**

- `firecrawl_research_search_papers`: cerca articoli di ricerca.
- `firecrawl_research_inspect_paper`: ispeziona un articolo.
- `firecrawl_research_related_papers`: trova articoli correlati.
- `firecrawl_research_read_paper`: leggi il contenuto dell'articolo.
- `firecrawl_research_search_github`: cerca repository GitHub.

**Ideale per:** Revisione della letteratura, ricerca di articoli e flussi di lavoro di scoperta di repository dove l'agente necessita di una superficie di ricerca mirata invece di un web scraping generico.

### 13. Strumenti di Monitoraggio (`firecrawl_monitor_*`)

Crea e gestisci monitoraggi periodici di pagine. I monitoraggi eseguono scraping o crawling programmati, confrontano ogni risultato con l'ultimo snapshot conservato e possono notificare tramite webhook o email.

**Ideale per:**

- Monitorare una o poche pagine nel tempo
- Avvisare su modifiche significative utilizzando un obiettivo in linguaggio naturale
- Tracciare la cronologia dei controlli e le differenze a livello di pagina

**Pattern di creazione consigliato:**

Usa `page` o `pages` più `goal`. Il server MCP costruisce la richiesta di monitoraggio con una pianificazione di 30 minuti e l'API abilita automaticamente il giudizio di cambiamento significativo.

Il giudizio di cambiamento significativo viene eseguito automaticamente quando `goal` è impostato. I webhook di pagina espongono `isMeaningful` e `judgment` sugli eventi `monitor.page`.

Scrivi gli obiettivi come istruzioni di monitoraggio concise di 2-3 frasi. Indica cosa dovrebbe attivare un avviso, preserva qualsiasi ambito fornito dall'utente e includi esclusioni specifiche dell'intento solo quando sono ovvie dalla richiesta. Il rumore generico come spazi bianchi, modifiche di sola formattazione, ID di richiesta, parametri di tracciamento, metadati generici e chrome di pagina non correlati è già gestito dal giudice, quindi non ripeterlo in ogni obiettivo. Se l'utente è vago, mantieni l'obiettivo ampio; se richiede un monitoraggio ampio o "qualsiasi cambiamento", preservalo. Se l'utente dice che non gli interessa qualcosa, includilo esplicitamente.```json
{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "page": "https://example.com/pricing",
    "goal": "Alert when pricing, packaging, or launch messaging changes."
  }
}

Pagine multiple con webhooks:```json { "name": "firecrawl_monitor_create", "arguments": { "pages": ["https://example.com/pricing", "https://example.com/changelog"], "goal": "Alert when pricing, packaging, or launch messaging changes.", "webhookUrl": "https://example.com/webhooks/firecrawl" } }

root@kitploit:~
**Richieste di creazione avanzate:**

Passa `body` quando hai bisogno di target di crawl, tracciamento delle modifiche JSON, conservazione personalizzata, o controllo esplicito di `judgeEnabled`.```json
{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "body": {
      "name": "Docs monitor",
      "schedule": { "text": "hourly", "timezone": "UTC" },
      "goal": "Alert when docs pages add, remove, or materially change API behavior.",
      "targets": [{ "type": "crawl", "url": "https://example.com/docs" }]
    }
  }
}

Altri strumenti monitor:

  • firecrawl_monitor_list: elenca i monitor.
  • firecrawl_monitor_get: ottiene un monitor.
  • firecrawl_monitor_update: aggiorna i campi inclusi goal, judgeEnabled, webhook e notification.
  • firecrawl_monitor_run: attiva un controllo ora.
  • firecrawl_monitor_delete: elimina un monitor (distruttivo; chiamare solo quando l'utente intende rimuoverlo).
  • firecrawl_monitor_checks: elenca i controlli, opzionalmente filtrati per stato.
  • firecrawl_monitor_check: ottiene i risultati a livello di pagina, inclusi diff, snapshot, e .

Sistema di Logging

Il server include un logging completo:

  • Stato e progresso delle operazioni
  • Metriche delle prestazioni
  • Tracciamento dei limiti di frequenza
  • Condizioni di errore

Esempio di messaggi di log:``` [INFO] Firecrawl MCP Server initialized successfully [INFO] Starting scrape for URL: https://example.com [ERROR] Rate limit exceeded

root@kitploit:~
## Gestione degli errori

Il server fornisce una gestione robusta degli errori:

- Errori di limite di frequenza API segnalati al client MCP
- Messaggi di errore dettagliati
- Resilienza di rete

Esempio di risposta di errore:```json
{
  "content": [
    {
      "type": "text",
      "text": "Error: Rate limit exceeded"
    }
  ],
  "isError": true
}

Sviluppo```bash

Install dependencies

npm install

Build

npm run build

Run tests

npm test

root@kitploit:~
### Contribuire

1. Forka il repository
2. Crea il tuo branch di feature
3. Esegui i test: `npm test`
4. Invia una pull request

### Ringraziamenti ai contributori

Grazie a [@vrknetha](https://github.com/vrknetha), [@cawstudios](https://caw.tech) per l'implementazione iniziale!

Grazie a MCP.so e Klavis AI per l'hosting e a [@gstarwd](https://github.com/gstarwd), [@xiangkaiz](https://github.com/xiangkaiz) e [@zihaolin96](https://github.com/zihaolin96) per aver integrato il nostro server.

## Licenza

Licenza MIT - consulta il file LICENSE per i dettagli
Scarica lo strumento
StrumentoIdeale perRestituisce
scrapeContenuto di una singola paginaJSON (preferito) o markdown
interactInteragire con un URL o una pagina estrattaRisultato dell'esecuzione + scrapeId per la modalità URL
mapScoprire URL su un sitoURL[]
crawlEstrazione multi-pagina (con limiti)stato/dati finali di crawl dopo polling interno
parseFile e riferimenti a upload ospitatimarkdown, JSON, o output documentale
extractEstrazione strutturata da URLDati strutturati JSON
searchRicerca sul web per informazioniresults[]
agentRicerca complessa multi-fonteJSON (dati strutturati)
monitorControlli periodici delle paginemetadati e differenze di monitor/check
researchRicerca su articoli e repository GitHubrisultati di ricerca e corrispondenze repository
judgment.meaningful
judgment.meaningfulChanges