horizen-mcp
OfficialThis MCP server gives coding agents accurate, sourced Horizen chain facts and a few live data lookups.
Get mainnet/testnet chain metadata: chain ID, RPC/WS URLs, explorer, gas token, settlement layer.
Get verified contract addresses on mainnet/testnet, with explicit not-found rather than guesses; list all registered contracts.
Get token info for ZEN, cbBTC, and USDC.e: Horizen addresses, decimals, and cross-chain addresses.
Compute Stork oracle feed IDs via keccak256 and fetch live signed Stork prices (requires STORK_API_KEY).
Get bridge info for the native Caldera bridge and Stargate, including supported assets and caveats.
Get integration details for Stork, Goldsky, PureFi, Den, and zkVerify: status, supported networks, access method, and docs paths.
Check zkVerify aggregation status on-chain (existence check or full Merkle proof verification) on mainnet or testnet.
All registry responses include a source and verified date; unknown values are explicitly reported as unknown, never fabricated.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@horizen-mcp What's the Horizen mainnet chain ID and RPC URL?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
horizen-mcp
An MCP server that gives coding agents accurate, sourced facts about the Horizen chain — so they stop guessing.
When you ask an agent to deploy a contract on Horizen, configure a bridge, or integrate Stork oracle or zkVerify, it needs ground truth: the right chain ID, the right RPC URL, the right contract address. This server provides that — typed, versioned, with explicit provenance on every value. If something isn't in the registry, the agent is told so explicitly rather than making something up.
Requirements
Node.js >= 20
A Stork API key in the
STORK_API_KEYenvironment variable, only if you use the livefetch_stork_pricetool.
Related MCP server: zkVerify
Quickstart
Published on npm as @horizen/horizen-mcp.
Claude Code
Add it to your project's .mcp.json:
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"]
}
}
}Claude Desktop
Edit the Claude Desktop config (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Windows: %APPDATA%\Claude\claude_desktop_config.json):
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"]
}
}
}Cursor
Add to ~/.cursor/mcp.json:
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"]
}
}
}Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"]
}
}
}Cline (VS Code)
Open the Cline extension, go to the MCP Servers tab, choose Edit MCP Settings, and add:
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"]
}
}
}Continue (VS Code / JetBrains)
Add to ~/.continue/config.yaml:
mcpServers:
- name: horizen
command: npx
args: ["-y", "@horizen/horizen-mcp"]Zed
Add to ~/.config/zed/settings.json:
{
"context_servers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"],
"env": {}
}
}
}Restart your editor after saving. The server starts on demand — no separate process to manage.
Stork API key (for fetch_stork_price)
Only the fetch_stork_price tool needs a key. It makes a live authenticated call to the Stork REST API, so supply a Stork API key through the STORK_API_KEY environment variable in your server config, alongside command and args:
{
"mcpServers": {
"horizen": {
"command": "npx",
"args": ["-y", "@horizen/horizen-mcp"],
"env": { "STORK_API_KEY": "your-stork-api-key" }
}
}
}The key is read from the environment and is never passed as a tool argument, so it stays out of the model's context and your chat history. Every other tool works without it. If your config file is committed to git (for example a project .mcp.json), reference the variable rather than hardcoding the key, e.g. "STORK_API_KEY": "${STORK_API_KEY}", so the secret stays out of the repo.
What you can ask
Once connected, your agent has access to Horizen chain facts through natural language:
Network info
"What's the Horizen mainnet chain ID and RPC URL?" "Give me the testnet explorer URL for Horizen."
Contract addresses
"What's the Stork oracle address on Horizen?" "What's the PureFi verifier proxy address I should integrate against?" "Is Uniswap deployed on Horizen mainnet?"
Tokens
"What's the cbBTC address and decimals on Horizen?" "List the tokens on Horizen with their decimals."
Oracle feeds and prices
"What's the Stork feed ID for ETHUSD on Horizen?" "How do I derive a Stork feed ID for a custom asset?" "Fetch the live signed Stork price for ETHUSD." (needs
STORK_API_KEY)
Bridges
"How do I bridge assets to Horizen?" "Does Stargate support ETH on Horizen?"
Integrations and proofs
"How do I integrate Stork oracle on Horizen?" "Can I use Den from the command line, or is it browser-only?" "Can I use zkVerify with Horizen? What's the contract address?" "Has zkVerify aggregation 42 on domain 1 been posted to Horizen?"
Tools
Tool | What it does |
| Chain ID, RPC/WS URLs, explorer, gas token, settlement layer for mainnet or testnet |
| Verified address for a given contract + network. Returns explicit not-found on miss — never fabricates. |
| All contracts in the registry with per-network deployment status |
| Addresses and decimals for ZEN, cbBTC, USDC.e on Horizen, plus cross-chain addresses |
| Stork oracle feed ID for an asset (e.g. |
| Bridge URLs, supported assets, and caveats — native bridge vs. Stargate |
| Docs paths, access method, status for Stork, Goldsky, PureFi, Den, zkVerify |
| Live authenticated pull from the Stork REST API for a signed price update. Network call; reads |
| Reads the zkVerify aggregation proxy on Horizen to confirm a proof aggregation. On-chain read. |
Most tools are offline lookups against the bundled registry. fetch_stork_price (Stork REST API) and check_zkverify_status (on-chain read) are the two that make live network calls.
Every response includes a source field and a verified date. If a value isn't in the registry, the agent gets an explicit not-found with a list of what is known — never a guess.
Run from source
git clone https://github.com/HorizenOfficial/horizen-mcp
cd horizen-mcp
npm install
npm run build
node dist/index.jsTo point your editor at a local build instead of npm:
{
"mcpServers": {
"horizen": {
"command": "node",
"args": ["/path/to/horizen-mcp/dist/index.js"]
}
}
}Development
npm run dev # watch mode — recompiles on save
npm run inspect # MCP Inspector UI for interactive tool testing
npm test # smoke test: builds, boots the server, and lists its toolsThe Inspector lets you call any tool directly and inspect the full JSON response before connecting to an editor.
Data
All facts live in data/chain-facts.json. Tool handlers query this file — nothing is hardcoded in source. To update a value, edit that file and run npm run build.
Every entry carries a source (URL or attribution) and a verified date. Values that haven't been confirmed are left as null rather than guessed — the tool will tell the agent the value is unknown rather than returning something fabricated.
Contributing
See CONTRIBUTING.md for how to add contracts, integrations, or tools.
License
MIT
Available Tools
9 toolscheck_zkverify_statusA
Check whether a zkVerify proof aggregation has been posted to Horizen by reading the zkVerify aggregation proxy contract. Two modes: (1) existence check — provide domainId and aggregationId only; reads proofsAggregations(domainId, aggregationId) and returns the Merkle root if posted; (2) full verification — also provide leaf, merklePath, leafCount, and index to call verifyProofAggregation(domainId, aggregationId, leaf, merklePath, leafCount, index) and get a definitive on-chain bool. Supports both mainnet (0xCb47A3C3B9Eb2E549a3F2EA4729De28CafbB2b69) and testnet (0x3098A6974649478f0133046e44105AA84e868C21).
Inputs: domainId (required), aggregationId (required), leaf, index, +3 more.
fetch_stork_priceA
Perform an authenticated pull from the Stork REST API to get a live signed price update for an asset. Reads the Stork API key from the STORK_API_KEY environment variable (not a tool argument). Returns the full signed payload with each field annotated with its correct Solidity type (timestampNs as uint64 in nanoseconds; quantizedValue as int192 — not uint256). Use the solidityCallData field directly when constructing an updateTemporalNumericValueV1 call.
Inputs: assetId (required), baseUrl.
get_bridge_infoA
Get bridge information for Horizen. Covers the native Caldera bridge and Stargate (LayerZero OFT). Always includes caveats about ETH/Stargate limitations.
Inputs: bridge, network.
get_chain_infoA
Get Horizen network metadata: chain ID, RPC URL, explorer URL, gas token, settlement layer.
Inputs: network (required).
get_contract_addressB
Get a verified contract address on Horizen mainnet or testnet. Returns explicit not-found when unavailable — never guesses.
Inputs: network (required), contract (required).
get_integration_infoB
Get details about a Horizen integration (stork, goldsky, purefi, den, zkverify) — category, status, supported networks, access method, and docs paths.
Inputs: integration.
get_stork_feed_idA
Compute the Stork oracle feed ID for an asset (e.g. ETHUSD). Derived via keccak256(assetId). Returns verified flag for known IDs.
Inputs: assetId (required).
get_token_infoA
Get token addresses and specs for tokens on Horizen: ZEN (governance, 18 decimals), cbBTC (Coinbase Bitcoin, 8 decimals — NOT 18), USDC.e (bridged USDC, 6 decimals). Returns Horizen address plus cross-chain addresses (Base, Base Sepolia). Omit token to list all tokens with their decimals.
Inputs: token, network.
list_contractsA
List all contracts in the registry with their display names and which networks they are deployed on.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool targets a distinct resource/action: integration metadata, Stork feed IDs, live Stork prices, contract registry listing/lookup, zkVerify proof status, bridge info, chain info, and token info. The only potentially related pairs (list_contracts vs get_contract_address, get_stork_feed_id vs fetch_stork_price) are clearly separated by action and description.
All tool names follow a consistent verb_noun snake_case pattern (get/list/fetch/check prefix plus a specific object). Verbs vary slightly but are semantically appropriate for each operation, and no naming style mixes with camelCase or vague terms.
Nine tools is a well-scoped size for an informational Horizen integration server. Each tool corresponds to a distinct useful query, and none feel redundant or filler.
The surface covers the apparent domain well: chain metadata, token and bridge details, contract registry lookup, Stork oracle feed derivation and price fetching, zkVerify status checks, and high-level integration info. For a read-only ecosystem information server, there are no major dead ends or missing lifecycle steps.
Maintenance
Related MCP Connectors
ChainRay provides multi-chain blockchain data and intelligence for AI agents through 79 MCP tools across 57 supported networks, covering gas, chain data, wallets, DeFi, market, security, monitoring, and verifiable proofs. MCP access is available at https://mcp.chainray.online/mcp; paid HTTP capabilities settle via x402 on Base.
Provable crypto data for AI agents: sourced checks on tokens, wallets and trades, with proof ids.
Evidence-backed crypto due diligence with sources, freshness, and a runtime receipt on every call.
Bitcoin and YouTube video intelligence for AI agents. Pay-per-call via x402 USDC on Base.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides grounded chain facts and build patterns for Rome Protocol, enabling agents to access live registry data and SDK patterns read-only.1MIT
- AlicenseAqualityBmaintenanceEnables AI agents to fetch and independently verify on-chain data such as account balances and contract code hashes using Merkle proofs and ECDSA signatures, with x402 payment integration.3MIT

swiftnodes-mcpofficial
AlicenseAqualityBmaintenanceEnables AI agents to retrieve multi-chain RPC details, live pricing, weekly-probed JSON-RPC method support, and probe any EVM endpoint for diagnostics.550 npmMIT- AlicenseAqualityCmaintenanceEnables AI agents to fetch crypto market and on-chain data, including prices across venues, token facts, OHLC candles, market overview, DeFi TVL, and wallet balances, with two free tools and the rest paid per call in USDC on Base via x402.8MIT