Hive Developer Portal

Guide for building LLM agents, automation bots, and Cursor/MCP-style tools on Hive. Prefer protocol-compatible libraries, public HTTPS nodes for reads, and constrained signing for writes.

Who this is for

• LLM agents and coding assistants that call Hive JSON-RPC or client libraries
• Automation bots that observe chain state, fetch data, and submit transactions
• Cursor, MCP, or similar tool integrations that need a stable stack and safe key handling

Preferred stack

Use this ladder unless you have a hard dependency on a legacy client:

1. WAX (@hiveio/wax) — protocol-compatible transaction and object handling (TypeScript, C++, Python)
2. Beekeeper — key management and signing without exposing keys in application logic
3. Workerbee (@hiveio/workerbee) — observe, fetch, and submit automation on top of WAX and Beekeeper
4. DHive / Hive-JS — legacy JavaScript clients; fine for existing apps, not preferred for new agent work

Public HTTPS nodes

Point read-only JSON-RPC at a public HTTPS API. Known stables include api.hive.blog, api.deathwing.me, and anyx.io. Prefer the live list and health details on Hive Nodes. Do not hard-code a single endpoint in production agents; rotate or fall back when a node is unhealthy.

Minimal JSON-RPC example

curl -s --data '{"jsonrpc":"2.0","method":"condenser_api.get_dynamic_global_properties","params":[],"id":1}' https://api.hive.blog

See also condenser_api.get_dynamic_global_properties and Understanding Dynamic Global Properties.

Auth and key safety

• Prefer the posting key (or Keychain / Beekeeper-managed signing) for agent writes that only need social or custom_json authority
• Never put active or owner keys in agent prompts, chat logs, CI output, or client-side source
• Budget resource credits (RC) before high-frequency broadcast; see RC API and the RC demo (Python)
• For interactive login flows, see Authentication (HiveSigner, Keychain, HiveAuth)

App data and analytics

• Use custom_json operations for application-specific payloads (id + JSON body) instead of overloading posts when you only need structured app state. Example pattern: Tic-Tac-Toe game
• For read-heavy analytics agents, prefer HAF (Hive Application Framework) SQL/API access over hammering condenser endpoints. See Setup HAF API node

Machine-readable JSON-RPC (OpenRPC)

The portal generates an OpenRPC document (and an OpenAPI 3 overlay) from _data/apidefinitions on every site build. Agents and codegen can ingest method names, short descriptions, and example-derived parameter/result shapes without scraping HTML.

• AppBase methods (for example database_api) use a named params object. condenser_api uses a positional params array.
• Shapes are inferred from documented examples. They are not a complete on-chain type system. Obsolete methods are marked deprecated.
• Call a public HTTPS node (for example https://api.hive.blog) with a JSON-RPC 2.0 POST. The HTML reference remains authoritative: JSON-RPC API.

Regenerate locally with bundle exec rake export:rpc_schema (writes api/openrpc.json and api/openapi.json). The published copies are produced by the Jekyll build at /openrpc.json and /openapi.json.

Workerbee tutorials

End-to-end portal recipes for @hiveio/workerbee (current WAX-chain constructor APIs):

• Workerbee getting started — install, start, stream blocks
• Subscribe and filter — accounts, posts/comments/votes, custom_json, .and / .or
• Errors and reconnect — observer errors, iterate(true), stop/start/delete, endpoint rotation

Upstream: Workerbee · filter categories

Reference MCP server

A read-only Model Context Protocol server in this repository (mcp/) turns the published OpenRPC document into tools. It does not sign, does not hold keys, and refuses broadcast methods unless you opt in. There is no public hosted endpoint; run it locally.

Tools:

• list_methods / get_method_schema — discover calls from /openrpc.json (not one MCP tool per RPC method)
• hive_rpc_call — JSON-RPC against an allowlisted public HTTPS node (https://api.hive.blog by default)
• fetch_doc_page — plain text of a page on developers.hive.io or developers-staging.hive.io

Resources: hive://schema/openrpc (catalog summary) and hive://method/{name} (one method descriptor).

cd mcp
npm ci
npm start

Cursor (stdio):

{
  "mcpServers": {
    "hive": {
      "command": "node",
      "args": ["/absolute/path/to/devportal/mcp/src/index.js"]
    }
  }
}

Production https://developers.hive.io/openrpc.json is published when develop is released to master. Until then the server falls back to staging (http://developers-staging.hive.io/openrpc.json). Override with HIVE_OPENRPC_URL or HIVE_OPENRPC_PATH.

network_broadcast_api, broadcast_*, and specialized mutators (for example chain_api.push_transaction) stay denied unless HIVE_MCP_ALLOW_BROADCAST=1. debug_node_api — including key-bearing debug_generate_blocks* — stays denied even with that opt-in. The process never accepts private keys — sign with Beekeeper or Keychain outside the MCP server. Default rate limit is 60 calls per minute (HIVE_MCP_RATE_LIMIT).

Design, Docker, and the allowlists: mcp/README.md in the devportal repository.

Portal machine-readable index

This portal publishes an agent-oriented link dump at https://developers.hive.io/llms.txt. Pair it with the WAX Mintlify llms.txt above when scaffolding Hive tooling.