Skip to main content
Glama

Search the Hetzner API reference

hetzner_search
Read-onlyIdempotent

Run JavaScript against the Hetzner API reference to locate operations, paths, parameters, and request bodies before querying or executing API calls—no token or API requests needed.

Instructions

Explore the Hetzner API reference (Cloud API incl. DNS zones, Storage Box API, and the Robot API for dedicated servers) by running JavaScript against it. Makes no API calls and needs no token. Use it before hetzner_query / hetzner_execute to find the right path, parameters and request body.

Globals available in the code: search(text) -> [{ operationId, method, path, summary, api }] where every word matches id, path, summary or tag. api is "cloud" | "hetzner" (both called via hetzner) or "robot" (called via robot) describe(ref) -> one operation, condensed: description, parameters, requestBody, response ("name*" = required). ref is an operationId or "METHOD /path". Robot operations have no JSON schema; their description lists Input, Output, Errors and the request limit, plus curl/JSON examples operations -> all operations with full JSON schemas: { api, operationId, method, path, summary, description, tags, deprecated, parameters, requestBody, response } apis -> { cloud, hetzner, robot }, each { baseUrl, overview, tags: [{ name, description }] }. overview is the general documentation in Markdown (pagination, label selectors, sorting, rate limits, errors)

Examples: async () => search('firewall') async () => describe('create_server') async () => describe('POST /servers/{id}/actions/rebuild') async () => search('robot firewall') async () => describe('robot_post_firewall_server_id') async () => operations.filter(o => o.tags.includes('Zone RRSets')).map(o => o.method + ' ' + o.path) async () => apis.cloud.overview.split('\n## ').find(s => s.startsWith('Label Selector'))

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "code": "<code>"
    },
    "name": "hetzner_search"
  }
}

Input Schema

NameRequiredDescriptionDefault
codeYesJavaScript: an async arrow function whose return value is the result.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.1

TDQS

A4.7/5.0
Behavior4/5

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, but the description adds genuinely new behavior: no API calls are made, no token is required, and the returned shapes differ per api family (robot operations lack JSON schemas and instead list Input, Output, Errors and request limits). It stops short of noting execution limits on the code sandbox itself (timeouts, size caps on `operations`), which is the only material behavior left unsaid.

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?

Front-loaded with purpose and the when-to-use rule before the mechanical detail, and the indented globals block plus example list is well organized. It runs slightly long — six examples cover a few near-redundant cases (two describe variants, two search variants) where four would have sufficed.

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

Completeness5/5

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

For a single-parameter code-execution tool with no output schema, the description is complete: it explains what is callable, what each helper returns, how to reach full JSON schemas, and where the general docs (pagination, label selectors, rate limits, errors) live via apis.*.overview. An agent could write a correct call from this text alone.

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

Parameters5/5

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

Schema coverage is 100% for the single `code` parameter, but the description goes far beyond it by documenting the actual sandbox surface: search(), describe(), operations, and apis, including the meaning of return fields, the '*' required-marker convention, and the api value mapping to the `hetzner` and `robot` clients. That is precisely the semantics an agent needs to write valid code.

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?

States a specific verb and resource ('Explore the Hetzner API reference ... by running JavaScript against it') and enumerates exactly which APIs are covered (Cloud incl. DNS zones, Storage Box, Robot). It is unmistakably a discovery/sandbox tool, clearly distinct from its siblings hetzner_query and hetzner_execute, which it names directly.

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

Usage Guidelines5/5

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

Gives explicit sequencing guidance: 'Use it before hetzner_query / hetzner_execute to find the right path, parameters and request body.' It also closes off the most likely wrong assumption by stating 'Makes no API calls and needs no token,' so an agent knows this is safe, offline reconnaissance rather than an execution path.

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

Deploy Server

Other Tools