mcpField
G
greynoise

greynoise

Local
github.com/nickjluckerSecurity0Updated 35w ago

About greynoise

mcp-greynoise is a read-only MCP server that checks IPv4 addresses against GreyNoise for internet scanning activity, benign services, and threat classification. Security teams can check one address or batches of up to 10, with status and rate-limit information also available.

Key features

  1. 01Check a single IPv4 address
  2. 02Check up to 10 IP addresses per call
  3. 03Identify scanning activity and classifications
  4. 04Flag known benign services through RIOT
  5. 05Expose API status and rate-limit information
  6. 06Read-only lookups without request data storage

Use cases

  1. 01Triage alert IPs as background noise or possible targeting
  2. 02Enrich incident-response investigations of attacker addresses
  3. 03Find non-scanning IPs in logs for threat hunting
  4. 04Reduce false positives from known scanners

MCP support

Exposes GreyNoise IP lookups and an API status resource to MCP clients. It only reads from GreyNoise and does not store data beyond the current request.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"nickjlucker-greynoise": {
"command": "npx",
"args": [
"-y",
"mcp-greynoise"
],
"env": {
"GREYNOISE_API_KEY": "<GREYNOISE_API_KEY>"
}
}
}
}
Run commandnpx -y mcp-greynoise
Environment variables to set
GREYNOISE_API_KEYSecretGreyNoise API key (free Community tier: 50 req/day)

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npmmcp-greynoise0.1.0

Tools

2

Saved tool list · updated 2w ago

ParameterTypeRequiredDescription
ipstringYesIPv4 address to check (e.g., 8.8.8.8)

Details

From the project README

mcp-greynoise

npm version License: MIT

MCP server for the GreyNoise API — check if IP addresses are internet background noise or potentially targeted attacks.

Quick Start

npx mcp-greynoise

That's it. Works out of the box with 10 lookups/day (no API key needed).

What is GreyNoise?

GreyNoise collects and analyzes internet-wide scan traffic. It tells you:

  • Noise: Is this IP mass-scanning the internet? (botnets, researchers, crawlers)
  • RIOT: Is this IP a known benign service? (Google, Cloudflare, Microsoft, etc.)
  • Classification: Malicious, benign, or unknown
Why this matters for security

When you see suspicious traffic in your logs:

GreyNoise ResultInterpretation
NOISE + MaliciousBackground attack traffic (scanners, botnets) — likely untargeted
NOISE + BenignSecurity researchers, search crawlers — usually safe
RIOTKnown good service (CDN, DNS, cloud) — almost certainly benign
NOT NOISE⚠️ This IP is NOT mass-scanning — traffic may be targeted at you

The "NOT NOISE" case is often the most important — it suggests someone is specifically interested in your systems.

Demo

Example output from check_ip:

IP: 51.91.185.74
Classification: MALICIOUS
Noise: YES - This IP has been observed scanning the internet
RIOT: NO - Not a known benign service IP
Last Seen: 2024-01-15
Details: https://viz.greynoise.io/ip/51.91.185.74

--- Interpretation ---
🚨 This IP is actively scanning the internet and classified as MALICIOUS. 
   Likely a scanner, botnet, or threat actor.

Installation

npm (recommended)
npm install -g mcp-greynoise
npx (no install)
npx mcp-greynoise
From source
git clone https://github.com/nickjlucker/mcp-greynoise.git
cd mcp-greynoise
npm install
npm run build
node build/index.js

Configuration

Claude Desktop

Add to your claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "greynoise": {
      "command": "npx",
      "args": ["mcp-greynoise"],
      "env": {
        "GREYNOISE_API_KEY": "your-api-key-here"
      }
    }
  }
}
Environment Variables
VariableRequiredDescription
GREYNOISE_API_KEYNoAPI key for higher rate limits (50/day vs 10/day)

Get a free API key at viz.greynoise.io/signup.

⚠️ Never commit API keys. See .env.example for the recommended setup.

Tools

check_ip

Check a single IP address against GreyNoise.

Input:

  • ip (string): IPv4 address to check
check_ips

Check multiple IP addresses in one call (max 10).

Input:

  • ips (string[]): Array of IPv4 addresses

Example output:

=== Results ===
8.8.8.8: RIOT (benign service) [Google]
51.91.185.74: NOISE - MALICIOUS
192.168.1.1: NOT NOISE (potentially targeted)

--- Legend ---
RIOT: Known benign service (CDN, DNS, etc.)
NOISE: IP is mass-scanning the internet
NOT NOISE: IP is NOT mass-scanning (traffic may be targeted)

Resources

greynoise://status

Returns API status and rate limit information.

Rate Limits

TierDaily Lookups
Unauthenticated10
Free account50
Paid plansHigher

Rate limits are shared between API calls and the GreyNoise Visualizer.

Security

This server:

  • Only reads from the GreyNoise API (no scanning, no exploitation)
  • Does not store any data beyond the current request
  • Does not transmit your API key anywhere except to GreyNoise
  • Performs reputation/telemetry enrichment only

Your API key is passed via environment variable and never logged.

Use Cases

  • SOC Triage: Quickly determine if alert IPs are background noise or targeted
  • Incident Response: Identify if attacker IPs are mass-scanners or focused threats
  • Threat Hunting: Find IPs in your logs that aren't mass-scanners (potentially targeted)
  • Log Analysis: Reduce false positives by filtering out known scanners

Development

# Install dependencies
npm install

# Run in development mode
npm run dev

# Build for production
npm run build

# Run built version
npm start

License

MIT

Links

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.