# RIPE Atlas (npm · ripe-atlas-mcp-server)

RIPE Atlas network measurements — ping, traceroute, DNS, TLS, HTTP, NTP, and probes

- Trust score: 75/100 (medium)
- Change this week: +34
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-04

## Components

- npm · `ripe-atlas-mcp-server`: 75/100 (this document), [markdown](https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server.md), [page](https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `ripe-atlas-mcp-server`
- Version: `1.0.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-04.

- **Supply Chain Security**: 83/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known medium-severity CVE affects hono 4.12.33, reached via @modelcontextprotocol/sdk > hono. A fixed version is available.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (107 of 108), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to jrelph/ripe-atlas-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 27 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 57/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4832 tokens (~371/item across 13 items; 13 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add jrelph-ripe-atlas -- npx -y ripe-atlas-mcp-server
```

### Codex

```bash
codex mcp add jrelph-ripe-atlas -- npx -y ripe-atlas-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jrelph-ripe-atlas": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "ripe-atlas-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add jrelph-ripe-atlas --command npx --arg -y --arg ripe-atlas-mcp-server
```

### Hermes

```yaml
mcp_servers:
  jrelph-ripe-atlas:
    command: "npx"
    args: ["-y", "ripe-atlas-mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "jrelph-ripe-atlas": {
      "command": "npx",
      "args": [
        "-y",
        "ripe-atlas-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-04 (score 75, −1)

- [security regression] CVE-2026-69207 affects this package: medium
- [security regression] Known CVEs: partial → fail

### 2026-08-03 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 75, +58)

- [security improvement] Provenance: unverified → pass
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [security] The attested source repository moved: jrelph/ripe-atlas-mcp
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Stability: unverified → 0.23
- [functional improvement] MCP protocol: unverified → pass
- [functional] Licence: MIT

### 2026-08-01 (score 17, −6)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 23, −1)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-30 (score 24, −17)

- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified

### 2026-07-27 (score 41)

First indexed and scored.

## MCP tools (13)

### `atlas_measure_ping` (~570 tokens)

RIPE Atlas Ping Measurement

Create a ping measurement on the RIPE Atlas network.

Sends ICMP echo requests from distributed probes worldwide to a target host.

Args:
  \- target (string): Target hostname or IP address
  \- af (4|6): Address family (default: 4)
  \- packets (1-16): Number of packets (default: 3)
  \- size (1-2048): Packet size in bytes (default: 48)
  \- probe_count (1-1000): Number of probes (default: 5)
  \- from_country/from_asn/from_prefix/from_area/from_probes: Probe selection
  \- is_oneoff (bool): One-shot measurement (default: true)
  \- response_format ('json'|'markdown'): Output format

Returns: Measurement ID(s) and link to results.

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `description` (string): Human-readable description of the measurement
- `exclude_tags` (array): Exclude probes with these tags
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `packet_interval` (integer): Time between packets in ms (2-30000, default: 1000)
- `packets` (integer): Number of packets to send (1-16, default: 3)
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `size` (integer): Packet size in bytes excluding headers (1-2048, default: 48)
- `tags` (array): Tags to apply to the measurement
- `target` (string, required): Target hostname or IP address

### `atlas_measure_traceroute` (~671 tokens)

RIPE Atlas Traceroute Measurement

Create a traceroute measurement on the RIPE Atlas network.

Traces the network path from distributed probes to a target, showing each hop.

Args:
  \- target (string): Target hostname or IP
  \- protocol ('ICMP'|'UDP'|'TCP'): Protocol (default: ICMP)
  \- max_hops (1-255): Max TTL (default: 32)
  \- paris (0-64): Paris traceroute mode (default: 16, 0=standard)
  \- port (1-65535): Destination port (TCP only)
  \- probe_count, from_country, etc.: Probe selection

Returns: Measurement ID(s).

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `description` (string): Human-readable description of the measurement
- `destination_option_size` (integer): IPv6 destination option header size
- `dont_fragment` (boolean): Set Don't Fragment flag
- `exclude_tags` (array): Exclude probes with these tags
- `first_hop` (integer): First TTL hop (1-255, default: 1)
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `hop_by_hop_option_size` (integer): IPv6 hop-by-hop option header size
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `max_hops` (integer): Maximum TTL hops (1-255, default: 32)
- `packets` (integer): Number of packets per hop (1-16, default: 3)
- `paris` (integer): Paris traceroute variant (0=standard, 1-64=Paris, default: 16)
- `port` (integer): Destination port (TCP only)
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `protocol` (string): Protocol to use: ICMP, UDP, or TCP
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `size` (integer): Packet size in bytes (1-2048, default: 48)
- `tags` (array): Tags to apply to the measurement
- `target` (string, required): Target hostname or IP address
- `timeout` (integer): Timeout per packet in ms

### `atlas_measure_dns` (~689 tokens)

RIPE Atlas DNS Measurement

Create a DNS measurement on the RIPE Atlas network.

Performs DNS lookups from distributed probes. Can query specific DNS servers or use the probe's local resolver.

Args:
  \- query_argument (string): DNS name to query (e.g. 'example.com')
  \- query_type: Record type (A, AAAA, MX, NS, SOA, TXT, CNAME, DNSKEY, etc.)
  \- target (string, optional): DNS server to query. Omit to use probe's resolver.
  \- set_rd_bit: Recursion Desired (default: true)
  \- set_do_bit: DNSSEC OK flag
  \- set_cd_bit: DNSSEC Checking Disabled
  \- set_nsid_bit: Request Name Server ID
  \- protocol ('UDP'|'TCP'): Transport (default: UDP)
  \- probe_count, from_country, etc.: Probe selection

Returns: Measurement ID(s).

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `description` (string): Human-readable description of the measurement
- `exclude_tags` (array): Exclude probes with these tags
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `protocol` (string): Transport protocol for DNS query
- `query_argument` (string, required): DNS name to query (e.g. 'example.com')
- `query_class` (string): DNS query class (default: IN)
- `query_type` (string): DNS query type (default: A)
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `retry` (integer): Number of retries
- `set_cd_bit` (boolean): Set DNSSEC Checking Disabled flag (RFC4035)
- `set_do_bit` (boolean): Set DNSSEC OK flag (RFC3225)
- `set_nsid_bit` (boolean): Include EDNS Name Server ID request
- `set_rd_bit` (boolean): Set Recursion Desired flag
- `tags` (array): Tags to apply to the measurement
- `target` (string): Target DNS server IP/hostname. If omitted, the probe's resolver is used.
- `udp_payload_size` (integer): EDNS UDP payload size (512-4096)

### `atlas_measure_tls` (~430 tokens)

RIPE Atlas TLS Certificate Measurement

Create a TLS/SSL certificate check measurement on the RIPE Atlas network.

Connects to a target and retrieves its TLS certificate from distributed probes worldwide.

Args:
  \- target (string): Target hostname or IP
  \- port (1-65535): Port to connect to (default: 443)
  \- probe_count, from_country, etc.: Probe selection

Returns: Measurement ID(s).

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `description` (string): Human-readable description of the measurement
- `exclude_tags` (array): Exclude probes with these tags
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `port` (integer): Port to connect to (default: 443)
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `tags` (array): Tags to apply to the measurement
- `target` (string, required): Target hostname or IP address

### `atlas_measure_http` (~636 tokens)

RIPE Atlas HTTP Measurement

Create an HTTP measurement on the RIPE Atlas network.

Makes HTTP requests from distributed probes to a target web server.

Args:
  \- target (string): Target hostname or IP
  \- method ('GET'|'HEAD'|'POST'): HTTP method (default: GET)
  \- path (string): URL path (default: '/')
  \- port (1-65535): Port (default: 80)
  \- version (string): HTTP version (default: '1.1')
  \- header_bytes: Max header bytes to capture
  \- body_bytes: Max body bytes to capture
  \- timing_verbosity (0|1|2): Detail level
  \- probe_count, from_country, etc.: Probe selection

Returns: Measurement ID(s).

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `body_bytes` (integer): Max bytes to retrieve from response body (0=no limit)
- `description` (string): Human-readable description of the measurement
- `exclude_tags` (array): Exclude probes with these tags
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `header_bytes` (integer): Max bytes to retrieve from response header (0=no limit)
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `method` (string): HTTP method
- `path` (string): URL path (default: '/')
- `port` (integer): Port number (default: 80)
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `query_string` (string): Query string to append to path
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `tags` (array): Tags to apply to the measurement
- `target` (string, required): Target hostname or IP address
- `timing_verbosity`: Timing detail: 0=none, 1=basic, 2=per-read
- `user_agent` (string): Custom User-Agent header
- `version` (string): HTTP version (e.g. '1.0', '1.1')

### `atlas_measure_ntp` (~453 tokens)

RIPE Atlas NTP Measurement

Create an NTP measurement on the RIPE Atlas network.

Queries NTP time servers from distributed probes to measure clock offset and delay.

Args:
  \- target (string): NTP server hostname or IP
  \- packets (1-16): Number of packets (default: 3)
  \- timeout: Timeout per packet in ms
  \- probe_count, from_country, etc.: Probe selection

Returns: Measurement ID(s).

Requires: RIPE_ATLAS_API_KEY with 'create measurement' permission.

Input parameters:

- `af`: Address family: 4 for IPv4, 6 for IPv6
- `description` (string): Human-readable description of the measurement
- `exclude_tags` (array): Exclude probes with these tags
- `from_area` (string): Geographic area to select probes from
- `from_asn` (integer): ASN number to select probes from
- `from_country` (string): Two-letter ISO country code to select probes from (e.g. 'DE', 'US')
- `from_prefix` (string): IP prefix to select probes from (e.g. '193.0.0.0/21')
- `from_probes` (string): Comma-separated list of specific probe IDs to use
- `include_tags` (array): Only include probes with these tags (e.g. ['system-ipv6-works'])
- `interval` (integer): Interval in seconds between measurements (only used when is_oneoff=false)
- `is_oneoff` (boolean): If true (default), run once. If false, run periodically at 'interval'
- `packets` (integer): Number of packets (1-16, default: 3)
- `probe_count` (integer): Number of probes to use (1-1000, default: 5)
- `resolve_on_probe` (boolean): Resolve DNS names on probe instead of RIPE servers
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `tags` (array): Tags to apply to the measurement
- `target` (string, required): Target hostname or IP address
- `timeout` (integer): Timeout per packet in ms

### `atlas_list_measurements` (~343 tokens)

List RIPE Atlas Measurements

Search and list RIPE Atlas measurements with comprehensive filters.

Args:
  \- search: Free-text search on target/description
  \- type: Filter by measurement type (ping, traceroute, dns, sslcert, http, ntp)
  \- status: Filter by status (2=Ongoing, 4=Stopped, etc.)
  \- af: Address family (4 or 6)
  \- target/target_contains: Filter by target
  \- mine: Show only your measurements (requires API key)
  \- page/page_size: Pagination
  \- sort: Sort order (e.g. '-id' for newest first)

Returns: Paginated list of measurements.

Input parameters:

- `af`: Address family filter
- `is_oneoff` (boolean): Filter one-off vs recurring
- `mine` (boolean): List only your own measurements (requires API key)
- `page` (integer): Page number (default: 1)
- `page_size` (integer): Results per page (1-500, default: 25)
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `search` (string): Free-text search (target or description)
- `sort` (string): Sort field (e.g. '-id', 'start_time')
- `status` (string): Filter by status: 0=Specified, 1=Scheduled, 2=Ongoing, 4=Stopped
- `target` (string): Filter by exact target
- `target_contains` (string): Filter by target containing string
- `type` (string): Filter by measurement type

### `atlas_get_measurement` (~102 tokens)

Get RIPE Atlas Measurement Details

Get detailed information about a specific RIPE Atlas measurement by ID.

Args:
  \- measurement_id (number): The measurement ID
  \- response_format ('json'|'markdown'): Output format

Returns: Full measurement metadata including type, target, status, probes, timestamps.

Input parameters:

- `measurement_id` (integer, required): The measurement ID to retrieve
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable

### `atlas_get_results` (~242 tokens)

Get RIPE Atlas Measurement Results

Retrieve results from a RIPE Atlas measurement.

Can fetch all results, latest results only, or filter by time range and probe IDs.

Args:
  \- measurement_id (number): The measurement ID
  \- latest (bool): If true, get only latest results (default: false)
  \- start (unix timestamp): Only results after this time
  \- stop (unix timestamp): Only results before this time
  \- probe_ids (string): Comma-separated probe IDs to filter
  \- response_format ('json'|'markdown'): Output format

Returns: Measurement results with per-probe data (RTT, hops, DNS answers, etc.)

Input parameters:

- `latest` (boolean): If true, fetch only the latest results instead of historical
- `measurement_id` (integer, required): The measurement ID to get results for
- `probe_ids` (string): Comma-separated list of probe IDs to filter results
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `start` (integer): Only results after this Unix timestamp
- `stop` (integer): Only results before this Unix timestamp

### `atlas_stop_measurement` (~66 tokens)

Stop RIPE Atlas Measurement

Stop a running RIPE Atlas measurement.

Args:
  \- measurement_id (number): The measurement ID to stop

Returns: Confirmation of the stop request.

Requires: RIPE_ATLAS_API_KEY with appropriate permissions.

Input parameters:

- `measurement_id` (integer, required): The measurement ID to stop

### `atlas_search_probes` (~441 tokens)

Search RIPE Atlas Probes

Search for RIPE Atlas probes worldwide with filters for location, network, and status.

Args:
  \- country (string): Two-letter ISO country code (e.g. 'DE', 'US', 'AU')
  \- asn (number): Filter by ASN (IPv4)
  \- asn_v6 (number): Filter by ASN (IPv6)
  \- prefix (string): Filter by IPv4 prefix (e.g. '193.0.0.0/21')
  \- prefix_v6 (string): Filter by IPv6 prefix
  \- status (1|2|3): 1=Connected, 2=Disconnected, 3=Abandoned
  \- is_anchor (bool): Only anchor probes
  \- tags (string): Comma-separated tag slugs
  \- search (string): Free-text search
  \- sort (string): Sort field (e.g. 'id', '-id')
  \- page/page_size: Pagination

Returns: Paginated list of probes with ID, country, ASN, status, tags.

Input parameters:

- `asn` (integer): Filter by ASN (v4)
- `asn_v6` (integer): Filter by ASN (v6)
- `country` (string): Filter by two-letter ISO country code
- `is_anchor` (boolean): Filter for anchor probes only
- `page` (integer): Page number (default: 1)
- `page_size` (integer): Results per page (1-500, default: 25)
- `prefix` (string): Filter by IPv4 prefix
- `prefix_v6` (string): Filter by IPv6 prefix
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable
- `search` (string): Free-text search across probe fields
- `sort` (string): Sort field (e.g. 'id', '-id' for descending)
- `status`: Probe status: 1=Connected, 2=Disconnected, 3=Abandoned
- `tags` (string): Comma-separated tag slugs to filter by

### `atlas_get_probe` (~104 tokens)

Get RIPE Atlas Probe Details

Get detailed information about a specific RIPE Atlas probe by ID.

Args:
  \- probe_id (number): The probe ID to retrieve
  \- response_format ('json'|'markdown'): Output format

Returns: Probe details including country, ASN, prefix, status, tags, coordinates.

Input parameters:

- `probe_id` (integer, required): The probe ID to retrieve
- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable

### `atlas_get_credits` (~85 tokens)

Get RIPE Atlas Credit Balance

Check your RIPE Atlas credit balance and usage statistics.

Args:
  \- response_format ('json'|'markdown'): Output format

Returns: Current balance, daily income/expenditure, estimated runout.

Requires: RIPE_ATLAS_API_KEY environment variable.

Input parameters:

- `response_format` (string): Output format: 'json' for structured data or 'markdown' for human-readable

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server#diagnostics

## Score history

- 2026-08-04: 75
- 2026-08-03: 76
- 2026-08-02: 75
- 2026-08-01: 17
- 2026-07-31: 23
- 2026-07-30: 24
- 2026-07-28: 41
- 2026-07-27: 41

## Links

- npm package: https://www.npmjs.com/package/ripe-atlas-mcp-server
- Socket report: https://socket.dev/npm/package/ripe-atlas-mcp-server
- Repository: https://github.com/jrelph/ripe-atlas-mcp
- Website: https://atlas.ripe.net/
- Changelog RSS feed: https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/jrelph-ripe-atlas/ripe-atlas-mcp-server