Skip to main content
Glama
CorbettCajun

SpiderFoot MCP Server

by CorbettCajun
OverviewSchemaRelated ServersScoreDiscussions
JavaScript
Hybrid

SpiderFoot MCP Agent

A Node.js implementation of the Model Context Protocol (MCP) server that exposes SpiderFoot's functionality as tools. This project provides both an MCP server and a web client for interacting with the SpiderFoot web interface.

Features

  • MCP Server: Exposes SpiderFoot functionality through the Model Context Protocol

  • Web Client: Programmatic interface to interact with SpiderFoot's web interface

  • TypeScript Support: Full TypeScript support for better development experience

  • Docker Support: Easy deployment using Docker

  • Modular Design: Easy to extend with new functionality

Related MCP server: BBOT MCP Server

Requirements

  • Node.js 18+ (recommended 20+)

  • A local SpiderFoot instance (Docker or direct installation)

    • Default web interface URL: http://127.0.0.1:5001

  • Docker (optional, for containerized deployment)

Setup

Prerequisites

  1. Ensure you have a running instance of SpiderFoot

  2. Clone this repository:

    git clone https://github.com/yourusername/Spiderfoot-MCP-Agent.git
cd Spiderfoot-MCP-Agent

Installation

  1. Install dependencies:

    npm install

  2. Configure environment:

    cp .env.example .env

    Edit the .env file with your SpiderFoot details:

    # Base URL of your SpiderFoot instance
SPIDERFOOT_BASE_URL=http://127.0.0.1:5001

# Authentication (if enabled in SpiderFoot)
# SPIDERFOOT_USER=username
# SPIDERFOOT_PASS=password

# Allow starting scans through the API
ALLOW_START_SCAN=true

Usage

Running the MCP Server

Development Mode (stdio transport)

npm run dev

Development Mode (HTTP transport)

npm run dev:http

Production Build

# Build the project
npm run build

# Start the server
npm start

Using the Web Client

The package includes a web client that can be used to interact with the SpiderFoot web interface programmatically.

import { SpiderFootWebClient } from './spiderfoot-web-client.js';

// Create a new client instance
const client = new SpiderFootWebClient('http://127.0.0.1:5001');

// List all scans
const scans = await client.listScans();
console.log('Existing scans:', scans);

// Start a new scan
try {
  const result = await client.startScan('example.com', ['type_DNS_TEXT'], 'domain', 'test-scan');
  console.log('Scan started:', result);
} catch (error) {
  console.error('Failed to start scan:', error);
}

Development

Building the Project

npm run typecheck
npm run build

Start from compiled output:

npm start            # stdio transport
npm run start:http   # HTTP transport (dist/index-http.js)

Tools

The server registers the following tools:

  • spiderfoot_ping – GET /ping

  • spiderfoot_modules – GET /modules

  • spiderfoot_event_types – GET /eventtypes

  • spiderfoot_scans – GET /scanlist

  • spiderfoot_scan_info – GET /scanopts?id=<sid>

  • spiderfoot_start_scan – POST /startscan (guarded by ALLOW_START_SCAN)

  • spiderfoot_scan_data – POST /scaneventresults

  • spiderfoot_scan_data_unique – POST /scaneventresultsunique

  • spiderfoot_scan_logs – POST /scanlog

  • spiderfoot_export_json – POST /scanexportjsonmulti

Dangerous endpoints like /query are intentionally omitted.

HTTP vs stdio transports

  • src/index.ts uses the stdio transport (StdioServerTransport). This is commonly used when an IDE/agent launches your process and communicates via stdio.

  • src/index-http.ts uses the Streamable HTTP transport, listening on /:port/mcp (default port 3000). Use this for remote/HTTP-based MCP clients.

Environment variable for HTTP port:

  • MCP_HTTP_PORT (default: 3000)

Docker usage

This repo includes a Dockerfile and docker-compose.yml to run the MCP server in Docker.

Build the image:

docker build -t spiderfoot-mcp:local .

Run with Docker directly:

docker run --rm -p 3000:3000 \
  -e SPIDERFOOT_BASE_URL=http://host.docker.internal:5001 \
  -e ALLOW_START_SCAN=true \
  -e MCP_HTTP_PORT=3000 \
  --name spiderfoot-mcp spiderfoot-mcp:local

Or with Compose:

docker-compose up --build

Compose file (docker-compose.yml) configures:

  • Service: spiderfoot-mcp

  • Port mapping: 3000:3000

  • Default env points to your host’s SpiderFoot at http://host.docker.internal:5001

Notes:

  • On Linux, replace host.docker.internal with your host IP or use the container network to reach your SpiderFoot service.

  • Ensure SpiderFoot is reachable on port 5001 from inside the MCP container.

Environment variables

  • SPIDERFOOT_BASE_URL — Base URL of your SpiderFoot web UI/API.

  • ALLOW_START_SCAN — true|false. Enables/disables spiderfoot_start_scan tool. Default true.

  • SPIDERFOOT_USER, SPIDERFOOT_PASS — Optional HTTP Digest credentials if you enable auth in SpiderFoot.

  • MCP_HTTP_PORT — Port for HTTP transport (if using index-http.ts). Default 3000.

Project layout

  • src/index.ts — MCP server (stdio transport) and tool registration.

  • src/index-http.ts — MCP server (HTTP transport) with session management.

  • src/spiderfootClient.ts — Axios-based client for SpiderFoot endpoints.

  • Dockerfile — Multi-stage image: builds TS → runs HTTP server.

  • docker-compose.yml — Runs container with env defaults.

Using with IDEs and MCP-compatible clients

This section provides JSON-based configuration examples for connecting this MCP server from popular IDEs and tools. Two transport modes are supported:

  1. Stdio transport: the IDE launches your local process

  2. HTTP transport: the IDE connects to a running server at http://localhost:5002/mcp (Docker with compose) or http://localhost:3000/mcp when running npm run dev:http locally

You can use both; add two separate entries if your IDE supports it.

Docker-based JSON (stdio inside container)

If you prefer your IDE to launch the MCP server inside Docker (without needing a long-running compose service), use this stdio-in-container configuration. It runs the stdio entrypoint (dist/index.js) and communicates over stdin/stdout.

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ],
      "env": {}
    }
  }
}

Copy-paste Claude Desktop block (Docker stdio + HTTP):

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    },
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

Notes:

  • Make sure you have built the image (docker build -t spiderfoot-mcp:local . or docker-compose build).

  • This approach does not expose a port; it uses stdio via Docker (-i).

  • The host SpiderFoot URL is passed via -e SPIDERFOOT_BASE_URL=http://host.docker.internal:5001.

Common configuration examples

Stdio (local process)

{
  "mcpServers": {
    "spiderfoot-mcp-stdio": {
      "type": "stdio",
      "command": "node",
      "args": [
        "./node_modules/tsx/dist/cli.mjs",
        "src/index.ts"
      ],
      "cwd": "C:/dev-env.local/project-repos/Spiderfoot-MCP-Agent",
      "env": {
        "SPIDERFOOT_BASE_URL": "http://127.0.0.1:5001",
        "ALLOW_START_SCAN": "true"
      }
    }
  }
}

HTTP (connect to running server)

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

Notes:

  • If you prefer npm start instead of tsx, update command/args accordingly, e.g. command: "npm", args: ["run", "dev"].

  • On Windows, keep forward slashes in cwd or escape backslashes (e.g., C:\\dev-env.local\\project-repos\\Spiderfoot-MCP-Agent).

  • Ensure SpiderFoot is reachable at SPIDERFOOT_BASE_URL from the MCP server.

Windsurf

Steps:

  1. Open Settings → MCP (or Tools/Integrations section that manages MCP servers).

  2. Add a new server entry.

  3. Paste one of the JSON examples above into your MCP server configuration, merging with any existing mcpServers entries. Recommended options:

    • Docker stdio: spiderfoot-mcp-docker-stdio (uses command: docker)

    • HTTP: serverUrl to http://localhost:5002/mcp

  4. Save settings.

  5. Start the server if using HTTP mode (Docker Compose or npm run dev:http). For stdio, Windsurf will launch it automatically when needed.

Windsurf – Option 2: HTTP via serverUrl

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "serverUrl": "http://localhost:5002/mcp"
    }
  }
}

Windsurf – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

Notes:

  • Make sure you have built the image (docker build -t spiderfoot-mcp:local . or docker-compose build).

  • This approach does not expose a port; it uses stdio via Docker (-i).

  • The host SpiderFoot URL is passed via -e SPIDERFOOT_BASE_URL=http://host.docker.internal:5001.

Cursor

Steps:

  1. Open Cursor settings for MCP integrations.

  2. Add a new MCP server.

  3. Use the Docker stdio JSON to launch in a container, or the HTTP example to connect to http://localhost:5002/mcp.

  4. Save and test by listing tools from the MCP panel.

Cursor – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

Cursor – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

Claude Desktop

Claude Desktop reads a JSON configuration file that can include the mcpServers map shown above.

Typical configuration file locations:

  • Windows: %APPDATA%/Claude/claude_desktop_config.json

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

Add or merge one of the following under a top-level mcpServers object if your extension reads from it, or under the extension-specific key (e.g., "cline.mcpServers").

Claude Desktop – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

Claude Desktop – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

VS Code (Continue)

Configuration is typically stored in VS Code settings.json.

Common locations:

  • Windows: %APPDATA%/Code/User/settings.json

  • macOS: ~/Library/Application Support/Code/User/settings.json

  • Linux: ~/.config/Code/User/settings.json

Add or merge the following under a top-level mcpServers object if your extension reads from it, or under the extension-specific key (e.g., "continue.mcpServers").

VS Code (Continue) – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

VS Code (Continue) – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

Notes:

  • Some VS Code MCP extensions expect a namespaced key (e.g., continue.mcpServers). If so, copy the object assigned to mcpServers above into that namespaced setting.

  • Ensure the working directory (cwd) points at Spiderfoot-MCP-Agent/.

VS Code (Cline)

VS Code (Cline) – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

VS Code (Cline) – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

JetBrains (Continue plugin)

Open your JetBrains IDE settings → Continue → MCP (or Tools/Integrations) and add a server using the same JSON entries shown above.

If your IDE stores a JSON configuration file, place the same mcpServers map in that file and restart the IDE. Use stdio or HTTP entries per your preference.

JetBrains (Continue) – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

JetBrains (Continue) – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

Zed

Open Zed settings JSON (e.g., ~/.config/zed/settings.json) and add an MCP servers map. For many setups, a root-level mcpServers object works; otherwise, consult Zed’s MCP documentation for the exact key.

Zed – Option 1: Docker stdio

{
  "mcpServers": {
    "spiderfoot-mcp-docker-stdio": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "--add-host=host.docker.internal:host-gateway",
        "-e",
        "SPIDERFOOT_BASE_URL=http://host.docker.internal:5001",
        "spiderfoot-mcp:local",
        "node",
        "dist/index.js"
      ]
    }
  }
}

Zed – Option 2: HTTP

{
  "mcpServers": {
    "spiderfoot-mcp-http": {
      "type": "http",
      "url": "http://localhost:5002/mcp"
    }
  }
}

MCP Inspector (testing)

  • Stdio: run npm run dev and point Inspector to that command.

  • HTTP: run Docker Compose (or npm run dev:http) and connect Inspector to http://localhost:5002/mcp.

Notes

  • Source files are in src/:

    • src/index.ts – MCP server definition and tool registration (stdio).

    • src/index-http.ts – Streamable HTTP transport variant.

    • src/spiderfootClient.ts – HTTP wrapper around SpiderFoot endpoints using axios.

  • The project uses ESM ("type": "module"), TypeScript 5, and zod for input validation.

  • Default behavior allows starting scans; disable by setting ALLOW_START_SCAN=false.

Available Tools

10 tools
spiderfoot_event_typesEvent TypesB

List available SpiderFoot event types.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'List available SpiderFoot event types,' which implies a read-only operation, but doesn't specify if it returns all types, requires authentication, has rate limits, or describes the return format (e.g., list, JSON). For a tool with zero annotation coverage, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with zero waste. It's front-loaded with the core action ('List') and resource, making it highly efficient. Every word earns its place, and there's no redundancy or unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output, or usage context. For a list tool with no structured data to rely on, it should provide more guidance on what 'event types' entail and how to use the result.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it correctly avoids mentioning any. A baseline of 4 is appropriate as it doesn't mislead or omit parameter info.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('available SpiderFoot event types'), making the purpose unambiguous. It distinguishes from siblings like 'spiderfoot_modules' or 'spiderfoot_scans' by specifying 'event types' rather than modules or scans. However, it doesn't explicitly differentiate from all siblings (e.g., 'spiderfoot_scan_data' also lists data), so it's not a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., before starting a scan), or comparisons to siblings like 'spiderfoot_modules' (which lists modules, not event types). This leaves the agent without explicit usage instructions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_export_jsonExport JSONC

Export scan results in JSON for CSV of IDs.

ParametersJSON Schema
NameRequiredDescriptionDefault
idsYes

TDQS

C2.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It mentions exporting results but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires specific permissions, rate limits, or what the output looks like. For a tool with no annotations, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise with a single sentence, which is efficient and front-loaded. However, it's somewhat cryptic ('for CSV of IDs' could be clearer), and while there's no wasted text, it might be too brief to be fully informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no annotations, no output schema, and low parameter coverage, the description is incomplete. It doesn't provide enough context for an agent to understand the tool's behavior, output, or how it fits with siblings. For a tool with these gaps, more detail is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 1 parameter with 0% description coverage, and the description adds minimal semantics. It implies 'ids' relates to scan IDs in CSV format, but doesn't explain the format, constraints, or examples. This doesn't adequately compensate for the low schema coverage, leaving the parameter poorly understood.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool exports scan results in JSON format, which provides a basic purpose. However, it's vague about the resource scope ('for CSV of IDs' is ambiguous) and doesn't clearly distinguish from siblings like spiderfoot_scan_data or spiderfoot_scan_data_unique that might also retrieve scan data. It specifies the output format but lacks clarity on what exactly is exported.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives is provided. The description mentions 'for CSV of IDs', which might imply usage with multiple scan IDs, but it doesn't clarify prerequisites, when not to use it, or compare to sibling tools. This leaves the agent without clear usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_modulesModulesA

List available SpiderFoot modules.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'lists' modules, implying a read-only operation, but does not specify details like response format, pagination, or error handling. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It is front-loaded and wastes no words, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output, or usage context, which could be helpful for an agent. It meets the baseline for a simple list tool but does not excel.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, earning a baseline score of 4 for not adding unnecessary information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and the resource ('available SpiderFoot modules'), making the purpose specific and unambiguous. It distinguishes itself from siblings like 'spiderfoot_scans' (which lists scans) or 'spiderfoot_event_types' (which lists event types), focusing specifically on modules.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context (e.g., before starting a scan), or exclusions, leaving the agent to infer usage based on the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_pingPingA

Ping SpiderFoot server to verify it is responding.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses the behavioral trait of checking server response, which is appropriate for a ping operation. However, it lacks details like expected response format, timeout behavior, or error handling, which could enhance transparency for an agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the purpose without unnecessary words. Every part ('Ping SpiderFoot server to verify it is responding') earns its place by clearly conveying the tool's function in a minimal format.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is complete enough for a basic ping operation. It covers the core purpose and context. However, without an output schema, adding a hint about the response (e.g., success/failure status) could improve completeness for agent use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is acceptable here. A baseline of 4 is applied as it adequately handles the zero-parameter case without redundancy.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Ping') and target resource ('SpiderFoot server') with the explicit purpose of 'verify it is responding.' It distinguishes from siblings like 'spiderfoot_start_scan' or 'spiderfoot_scan_data' by focusing on server availability rather than operational tasks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context for verifying server responsiveness, which is clear for a ping tool. However, it does not explicitly state when not to use it or name alternatives, such as using other tools only after confirming server availability, leaving room for improvement in sibling differentiation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_scan_dataScan DataC

Fetch scan event results for a scan ID.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
eventTypeNo

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'fetches' results, implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns paginated data, or what the output format is (e.g., JSON, raw text). This leaves significant gaps for a tool that retrieves data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no wasted words. It's front-loaded with the core action ('Fetch scan event results') and condition ('for a scan ID'), making it efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (2 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return values, error conditions, or behavioral traits like data format or access requirements. For a data-fetching tool with undocumented parameters, this minimal description is insufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, so the description must compensate. It mentions 'scan ID' which maps to the 'id' parameter, but doesn't explain the 'eventType' parameter at all (e.g., what types are available, if it's optional for filtering). This partial coverage fails to fully clarify the parameters beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Fetch') and resource ('scan event results') with a specific condition ('for a scan ID'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'spiderfoot_scan_data_unique' or 'spiderfoot_scan_logs', which likely also retrieve scan-related data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing scan ID), exclusions, or comparisons to siblings like 'spiderfoot_scan_data_unique' for unique results or 'spiderfoot_scan_logs' for logs, leaving the agent to infer usage from context alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_scan_data_uniqueScan Data UniqueC

Fetch unique scan event results.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
eventTypeNo

TDQS

C2.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions fetching results but doesn't specify whether this is a read-only operation, if it requires authentication, rate limits, or what the output format looks like. This leaves significant gaps for a tool that likely interacts with scan data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of scan data tools, no annotations, no output schema, and low parameter coverage, the description is incomplete. It doesn't explain what 'unique' entails, how results are returned, or provide enough context for safe and effective use by an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, so parameters 'id' and 'eventType' are undocumented. The description adds no meaning beyond the schema, failing to explain what 'id' refers to (e.g., scan ID) or how 'eventType' filters results. This doesn't compensate for the low coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Fetch unique scan event results' clearly states the action (fetch) and resource (unique scan event results), but it's vague about what 'unique' means and doesn't differentiate from sibling tools like 'spiderfoot_scan_data' or 'spiderfoot_scan_logs'. It provides a basic purpose but lacks specificity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as 'spiderfoot_scan_data' or 'spiderfoot_scan_logs'. The description implies usage for fetching data but offers no context on prerequisites, exclusions, or comparisons with siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_scan_infoScan InfoC

Retrieve scan metadata/config for a scan ID.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves metadata/config, implying a read-only operation, but does not specify if it requires authentication, has rate limits, or details the return format. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose without unnecessary elaboration, earning a top score for brevity and structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (retrieving metadata/config), lack of annotations, and no output schema, the description is incomplete. It does not cover behavioral aspects like error handling, response format, or usage context, which are crucial for an agent to invoke the tool correctly in a real-world scenario.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has one parameter ('id') with 0% description coverage, so the schema provides no semantic context. The description adds minimal value by implying 'id' refers to a scan ID, but does not explain format, constraints, or examples. Since there is only one parameter, the baseline is higher, but the description does not fully compensate for the lack of schema details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Retrieve') and resource ('scan metadata/config for a scan ID'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'spiderfoot_scans' or 'spiderfoot_scan_data', which might also retrieve scan-related information, so it falls short of a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as distinguishing it from 'spiderfoot_scans' (which might list scans) or 'spiderfoot_scan_data' (which might retrieve actual scan results). There is no mention of prerequisites or context for usage, leaving the agent to infer based on tool names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_scan_logsScan LogsC

Fetch/poll scan logs for a given scan ID.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
limitNo
reverseNo
rowIdNo

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'fetch/poll', suggesting it might retrieve or monitor logs, but fails to clarify key traits such as whether this is a read-only operation, potential side effects, authentication needs, rate limits, or the format of returned logs. This is inadequate for a tool with multiple parameters and no output schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (4 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, parameter purposes beyond 'id', and what the tool returns (e.g., log format or structure). This leaves significant gaps for the agent to understand and use the tool effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 0%, so the description must compensate, but it only references the 'id' parameter ('for a given scan ID') and ignores 'limit', 'reverse', and 'rowId'. This adds minimal meaning beyond the schema, leaving most parameters undocumented and their purposes unclear to the agent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('fetch/poll') and resource ('scan logs') with a specific scope ('for a given scan ID'), making the purpose understandable. However, it doesn't differentiate from siblings like 'spiderfoot_scan_data' or 'spiderfoot_scan_info', which might also retrieve scan-related information, so it doesn't fully distinguish itself.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides minimal guidance by implying usage when logs for a specific scan ID are needed, but it offers no explicit advice on when to use this tool versus alternatives (e.g., 'spiderfoot_scan_data' or 'spiderfoot_scan_info'), prerequisites, or exclusions. This leaves the agent with insufficient context for optimal selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_scansScansB

List all scans (past and present).

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists scans but doesn't mention any behavioral traits such as whether it's read-only, if it includes pagination, rate limits, or authentication needs. This is a significant gap for a tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise and front-loaded, consisting of a single, clear sentence that directly states the tool's function. There is no wasted verbiage, making it efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values include (e.g., scan IDs, statuses, timestamps) or any behavioral context like pagination. For a tool that lists data, this leaves the agent with insufficient information to use it effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, but it could have hinted at implicit parameters like filtering options. Since there are no parameters, a baseline of 4 is justified, as the description doesn't need to compensate for any gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('List') and resource ('all scans'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'spiderfoot_scan_info' or 'spiderfoot_scan_data', which might also retrieve scan information, so it falls short of a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'spiderfoot_scan_info' or 'spiderfoot_scan_data' that might retrieve specific scan details, there's no indication of scope (e.g., this lists all scans broadly vs. others for detailed data), leaving usage ambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

spiderfoot_start_scanStart ScanC

Start a new scan against a target.

ParametersJSON Schema
NameRequiredDescriptionDefault
scannameYes
scantargetYes
modulelistNo
typelistNo
usecaseNo

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool starts a scan but doesn't mention critical traits such as whether this is a long-running operation, what permissions are required, potential rate limits, or what happens if a scan with the same name exists. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with a single sentence that directly states the tool's purpose. It is front-loaded with no wasted words, making it easy to parse quickly. This efficiency is appropriate for a simple action, though it sacrifices detail for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of starting a scan (a potentially resource-intensive operation), no annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't address key aspects like expected return values, error conditions, or operational constraints, making it inadequate for safe and effective use by an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, so the description must compensate by explaining parameters. It adds no meaning beyond the schema, failing to clarify what 'scanname', 'scantarget', 'modulelist', 'typelist', or 'usecase' represent. For example, it doesn't indicate if 'scantarget' is a URL, IP address, or domain, leaving parameters largely undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Start a new scan') and target ('against a target'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from sibling tools like 'spiderfoot_scans' or 'spiderfoot_scan_info', which might also relate to scan operations, leaving some ambiguity about its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., whether a target must be pre-configured) or comparisons to sibling tools like 'spiderfoot_scans' (which might list scans) or 'spiderfoot_scan_data' (which might retrieve results). This omission leaves the agent without clear usage direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: listing event types, exporting results, listing modules, pinging the server, fetching scan data (regular and unique), retrieving scan metadata, fetching logs, listing scans, and starting a scan. The descriptions make it easy to differentiate between them, such as distinguishing scan_data from scan_data_unique or scan_info from scan_logs.

Naming Consistency5/5

All tool names follow a consistent snake_case pattern with a 'spiderfoot_' prefix and descriptive suffixes (e.g., event_types, export_json, start_scan). This uniformity makes the tools predictable and easy to understand, with no deviations in style or structure across the set.

Tool Count5/5

With 10 tools, the server is well-scoped for managing SpiderFoot scans, covering key operations like listing, starting, fetching data, and exporting results. Each tool serves a specific function without redundancy, making the count appropriate for the domain of security scanning and reconnaissance.

Completeness5/5

The tool set provides complete coverage for scan management: listing scans, starting scans, retrieving metadata, data, logs, and exporting results, along with auxiliary functions like pinging and listing modules/event types. There are no obvious gaps, as it supports the full lifecycle from initiation to analysis and export.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • SpiderFoot MCP Server

    marlinkcyber
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables interaction with SpiderFoot's OSINT scanning capabilities through Claude and other MCP-compatible tools. Supports comprehensive scan management, real-time monitoring, result retrieval, and export functionality for reconnaissance and investigation workflows.
    6
    MIT

  • BBOT MCP Server

    marlinkcyber
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables users to run and manage BBOT security scans through the MCP interface. Provides comprehensive tools for executing reconnaissance scans, monitoring progress, and retrieving results with support for concurrent scanning operations.
    2
    MIT

  • Shodan MCP Server

    irootsec
    F
    license
    Not graded
    quality
    D
    maintenance
    Integrates Shodan search capabilities into MCP-compatible applications for discovering internet-connected devices. Enables domain searches, IP lookups, and advanced queries to identify exposed services, infrastructure mapping, and security analysis.
    3

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/CorbettCajun/Spiderfoot-MCP-Server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server