# Authentication
Source: https://docs.hiveintelligence.xyz/authentication
Three ways to authenticate with Hive: the anonymous lane, browser OAuth, and API keys for headless agents.
Hive has three access lanes. Which one you use depends on whether a human is present when
the agent connects.
## The anonymous lane
Add the endpoint and start asking. No account, no key.
You get 25 material calls per IP each day, resetting at 00:00 UTC. Discovery calls do not
count, so your agent can list tools and read schemas freely while it works out what to call.
This lane exists so you can evaluate Hive properly before signing up. It is not meant for
production traffic, and it is capped per IP rather than per user.
## OAuth for interactive clients
Clients like Claude, Cursor, VS Code, and ChatGPT authorize in the browser. You add only
the URL. When the client first connects, it opens a browser window, you approve the
connection, and the client stores the credential itself.
No secret goes in your config file with OAuth. If a setup guide tells you to paste a key
into `mcp.json`, you are looking at the headless path by mistake.
You can review and revoke connected clients any time from
[dashboard settings](https://www.hiveintelligence.xyz/dashboard/settings). Disconnecting
revokes every access and refresh token issued to that client.
## API keys for headless agents
Cron jobs, backends, and CI have no browser, so they use a key instead:
```
Authorization: Bearer YOUR_HIVE_API_KEY
```
Create one at [dashboard keys](https://www.hiveintelligence.xyz/dashboard/keys). A few
things worth knowing before you do:
* The full secret appears once, at creation. Hive stores a hash and a short non-secret
prefix afterwards, so there is no way to retrieve it later. Put it in your secret manager
immediately.
* Credits are tracked on your account, not per key. Creating a second key does not give you
a second allowance.
* Disabling a key stops it authenticating once the change propagates. Disabled keys stay
listed for audit history and stop counting toward your active key limit.
Never commit a Hive key or paste it into a client config that syncs to a repository. Use
an environment variable or your platform's secret storage.
## Which lane applies
| Situation | Lane |
| ------------------------------------------------ | ------------------------------- |
| Trying Hive out | Anonymous |
| Claude, Cursor, VS Code, ChatGPT, Windsurf, Grok | OAuth |
| Codex CLI, Gemini CLI, Kimi Code CLI | OAuth |
| Qwen Code | API key |
| Backend service, cron, CI | API key |
| Hive CLI on your machine | API key, from `hive auth login` |
## When a call is rejected
A rejected call tells you which lane failed and what to do next. The common cases:
* **Anonymous cap reached.** You have used your 25 material calls for the day. Sign in, or
wait for the 00:00 UTC reset.
* **Missing credential on a protected surface.** The agent tried something the anonymous
lane does not cover. Connect via OAuth or add a key.
* **Credits exhausted.** Your plan's monthly allowance is spent. Hive stops rather than
billing overage, so requests fail with a clear quota error until the cycle resets.
See [limits](/concepts/limits) for how credits and rate limits work.
# CLI commands
Source: https://docs.hiveintelligence.xyz/cli/commands
Reference for the Hive CLI, verified against the shipped command tree.
The CLI has three kinds of commands: ten data domains that query Hive directly, five management
groups, and a set of top-level utilities. Run `hive --help` for the list on your installed
version, or `hive --help` for one group.
## Data domains
These are the fastest way to get an answer. Each domain maps onto a set of tools, so you do not
have to look up a tool name first.
```bash theme={null}
hive market price --ids bitcoin --vs usd
```
| Domain | Subcommands |
| ---------------- | ------------------------------------------------------------------ |
| `hive market` | `price`, `top`, `trending`, `global`, `ohlc`, `chart`, `gainers` |
| `hive defi` | `tvl`, `protocols`, `fees`, `yields`, `chains`, `bridges` |
| `hive portfolio` | `balance`, `tokens`, `positions`, `nfts`, `history` |
| `hive security` | `scan`, `approve`, `simulate`, `rugpull` |
| `hive exchange` | `ticker`, `orderbook`, `trades`, `funding`, `list` |
| `hive dex` | `trending`, `pools`, `trades`, `volume`, `pairs` |
| `hive wallet` | `balances`, `transfers`, `transactions`, `approvals` |
| `hive nft` | `trending`, `collection`, `markets`, `search` |
| `hive network` | `chains`, `block-number`, `resolve` |
| `hive search` | `tokens`, `pools` |
| `hive archive` | `coverage`, `funding`, `oi`, `basis`, `long-short`, `liquidations` |
Run `hive --help` to see the flags each subcommand takes. Two things worth knowing:
* Every subcommand also accepts `--args ''` if you would rather pass the whole payload at
once.
* If you leave out a required flag in an interactive terminal, the CLI prompts you for it
instead of failing. In a script it exits with code 2, so pass every flag explicitly.
## Setup
| Command | What it does |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hive init` | Interactive per-client MCP setup |
| `hive init --all --browser` | Configure every detected client and install the skill packs, with browser sign-in |
| `hive setup [client]` | Set up one client, for example `hive setup cursor` |
| `hive doctor` | Check API key, endpoint reachability, tool catalog, updates, and today's keyless allowance |
| `hive upgrade` | Update the CLI |
| `hive uninstall` | Remove Hive MCP entries, delete copied skill packs, and remove any routing block this CLI wrote |
| `hive routing install` | Append the Hive routing block to this project's AGENTS.md, or CLAUDE.md when there is no AGENTS.md. `--file` picks one, `--create` makes it, `--dry-run` previews |
| `hive routing decline` | Record that this project does not want the routing block, so nothing asks again |
| `hive routing remove` | Remove the block and restore the file's original bytes |
`--all` installs all 18 skill packs into your clients' skills directories. Pass `--skip-skills`
to configure the clients without them, and `--skip-verify` to keep the whole command
non-interactive, which is what an agent should run. Both `init` and `uninstall` accept
`--dry-run` if you want to see what would change first.
`hive init` never reads or writes AGENTS.md or CLAUDE.md. The routing block is written only by
`hive routing install`, and `HIVE_ROUTING=never` disables that on a machine.
## Tools
Discovery and execution live under `hive tools`:
| Command | What it does |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
| `hive tools list` | List registered tools. Accepts `--category`, `--provider`, `--limit`, `--offset` |
| `hive tools search ` | Filter tools whose name, title, or description contains your text |
| `hive tools info ` | Show a tool's parameter table (name, type, required, enum values, default), response schema, and description |
| `hive tools call -- ` | Execute a tool with generated flags typed from its schema, in kebab-case or snake\_case |
| `hive tools call --args ''` | The same call with JSON instead. Flags win over `--args`, and JSON can be piped on stdin |
| `hive tools refresh` | Force-refresh the cached tool catalog |
`hive tools search` matches literal text, not intent. Search for a keyword like `funding` or
`nft`, not a phrase like "what is this token worth". A phrase that does not appear verbatim in
a tool's name or description returns no results.
`hive tools list` returns 50 tools at a time. Use `--limit` and `--offset` to page through the
full catalog.
## Authentication
| Command | What it does |
| ------------------------- | ------------------------------------------------ |
| `hive auth login` | Browser sign-in. `--manual` pastes a key instead |
| `hive auth logout` | Remove stored credentials |
| `hive auth whoami` | Show the current profile |
| `hive auth profiles` | List profiles |
| `hive auth switch ` | Switch the active profile |
Only `hive auth login` takes `--profile `. The other four commands act on the profile
that is already active, and reject `--profile` with `error: unknown option`. Use
`hive auth switch ` to change which one that is.
There is no signup command. `hive auth login` opens the browser, and an account is created on
first sign-in if you do not already have one.
## Keys
Key management lives in the dashboard, at
[hiveintelligence.xyz/dashboard/keys](https://www.hiveintelligence.xyz/dashboard/keys).
Most clients never need a key at all. Claude, Claude Code, Cursor and VS Code authorize
through the browser on first connect, and `hive auth login` stores a credential for the CLI.
A key is for the case with no browser to click: a server, a script, or CI.
## Client configuration
`hive config` prints setup instructions for a client rather than writing them, which is useful
when you want to apply them yourself or check what `setup` would do. What it prints depends on
how that client accepts remote servers:
| Command | What it prints |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `hive config cursor` | A `mcpServers` JSON block for `.cursor/mcp.json` |
| `hive config http [url]` | A generic JSON block for any MCP client |
| `hive config claude-desktop` | Numbered steps for the Connectors UI. Claude Desktop's config file is stdio-only, so there is no JSON block to paste |
| `hive config vscode` | A one-click `vscode:mcp/install` link and a `code --add-mcp` command |
| `hive config claude-code` | The `claude mcp add` command to run |
| `hive config codex` | The Codex MCP add and OAuth login commands |
| `hive config grok` | Instructions for adding a custom connector |
## Other
| Command | What it does |
| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hive` | With no subcommand, starts the stdio MCP server |
| `hive serve` | Run Hive as a local stdio MCP server. `--http` and `--port ` run the HTTP transport instead |
| `hive usage` | Show your current usage against your plan limits |
| `hive feedback ""` | Send one line of product feedback, up to 1,000 characters. `--tool` names the tool and `--receipt` ties it to a receipt, defaulting to your last call's |
| `hive status` | Version, active profile, masked key, and endpoint reachability |
| `hive open [target]` | Open `dashboard`, `docs`, `status`, or `github` in a browser |
| `hive watch ` | Re-run a domain command on an interval. `--interval ` defaults to 30 |
| `hive alias set ` | Save a shorthand for a call you run often |
| `hive alias list` | List saved aliases |
| `hive alias remove ` | Delete an alias |
| `hive telemetry enable\|disable\|status` | Control anonymous usage reporting, which is off by default |
| `hive completion ` | Generate completions for `bash`, `zsh`, `fish`, or `powershell`. `--install` writes them to your shell config, and supports `bash`, `zsh` and `fish` only |
`serve` is for clients that only speak stdio, or for local development against your own
provider keys. Most users should connect to the hosted endpoint instead.
## Scripting
`--json` gives output you can pipe:
```bash theme={null}
hive tools call get_token_price --args '{"token":"ETH"}' --json
```
The envelope has `ok`, `data`, and `meta`, where `meta` carries the tool name, provider, and
runtime status.
`--json` is honored by every data-domain subcommand and by `hive watch`, plus `hive tools
list`, `search`, `info`, and `call`, and `hive doctor`, `hive status`, and `hive upgrade`.
Commands that only print human-readable text, including everything under `auth`, ignore it and
write to stderr. Piping those to `jq` gives you an empty stdout, not an error.
Useful global flags:
| Flag | What it does |
| ------------------- | -------------------------------------------------- |
| `--json` | Machine-readable envelope |
| `--jq ` | Filter `data` with a built-in expression evaluator |
| `--fields ` | Keep only the named fields |
| `--csv` | CSV output when `data` is an array |
| `--api-key ` | Override the stored key for one command |
| `--timeout ` | Tool execution timeout, default `30000` |
| `--no-retry` | Do not retry on failure |
| `--no-cache` | Bypass the tool catalog cache |
| `--env-file ` | Load a specific `.env`, default `.env` |
| `-q, --quiet` | Suppress all non-data output |
| `-v, --verbose` | Show debug info |
`--jq` is a small built-in evaluator, not a bundled copy of `jq`. It supports `.field`, `.a.b`,
`.[N]`, `.[]`, and `select(.field op value)`. For anything more, pipe `--json` into real `jq`.
`-q` suppresses everything that is not data, including the tools table. `hive tools list -q`
prints nothing at all unless you also pass `--json`.
## Exit codes
Exit codes are stable, so `hive doctor` works as a health check in CI:
| Code | Meaning |
| ----- | ---------------------- |
| `0` | Success |
| `1` | General error |
| `2` | Invalid arguments |
| `3` | Tool not found |
| `4` | API error |
| `5` | Authentication failure |
| `6` | Rate limited |
| `124` | Timeout |
# Hive CLI
Source: https://docs.hiveintelligence.xyz/cli/index
Run the Hive catalog from your terminal for scripts, cron jobs, and setup checks.
The CLI reaches the same tools your agent does. It is useful when you want data in a shell
script, when you need to confirm credentials work, or when you are setting up a client and
want the config generated for you.
## Install
```bash theme={null}
npx -y -p hive-intelligence@latest hive init --all --browser
```
That one command installs the CLI, walks you through authentication in the browser, and
detects which AI clients you have so it can write their config for you.
Requires Node 22.12 or newer. The package is
[`hive-intelligence`](https://www.npmjs.com/package/hive-intelligence) on npm. Run
`hive status` to see which version you actually have, since npm can lag a release for a short
while after it is cut.
## Authenticate
```bash theme={null}
hive auth login
```
This opens a browser, you approve, and the CLI stores a key locally. Check it worked:
```bash theme={null}
hive auth whoami
```
For CI, set `HIVE_API_KEY` in the environment instead of running an interactive login.
## Your first call
```bash theme={null}
hive tools call get_token_price --args '{"token":"BTC"}'
```
Or search for the right tool first:
```bash theme={null}
hive tools search "funding rates"
```
## Check your setup
```bash theme={null}
hive doctor
```
`doctor` checks your API key, the endpoint, server health, the tool catalog, and whether a
CLI update is available. Run it first whenever something is not working.
Every command and what it does.
# Data sources
Source: https://docs.hiveintelligence.xyz/concepts/data-sources
The 15 data sources behind Hive, and what each one contributes.
Hive normalizes 15 data sources behind one interface. Twelve are external providers. The other
three are Hive's own: an archive of historical derivatives data, a normalized RWA perpetuals
feed, and an allowlisted fetch for public APIs that have no dedicated integration.
Your agent asks a question; Hive decides which source answers it and tells you which one it
used.
## The providers
| Provider | Contributes |
| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Alchemy](https://www.alchemy.com) | EVM wallet, token, NFT, transfer, simulation, gas, and network RPC data |
| [CoinGecko](https://www.coingecko.com) | Market data, OHLC, trending coins, exchange data, tokenized RWA markets, news |
| [DeFiLlama](https://defillama.com) | TVL, yields, fees, stablecoins, chain analytics |
| [GoPlus](https://gopluslabs.io) | Token, NFT, dApp, wallet security and risk analysis |
| [CCXT](https://github.com/ccxt/ccxt) | Centralized exchange spot, derivatives, funding rates |
| [Helius](https://www.helius.dev) | Solana RPC, Digital Asset Standard, priority fees, parsed transactions and Parsed Events |
| [Hyperliquid](https://hyperliquid.xyz) | Perpetual DEX volume, funding, candles, open-interest caps, builder DEX discovery, and HIP-4 outcome markets |
| [Open Data Fetch](https://www.hiveintelligence.xyz) | Allowlisted, size-capped access to long-tail public crypto APIs when no typed tool covers the source |
| [Polymarket](https://polymarket.com) | Prediction markets: market and event search, market-implied odds, CLOB order books, odds history, and wallet positions and activity |
| [Alternative.me](https://alternative.me/crypto/fear-and-greed-index/) | Crypto Fear and Greed Index, current reading plus daily history |
| [Blockchain.com](https://www.blockchain.com/explorer/charts) | Daily Bitcoin on-chain charts: hash rate, active addresses, transaction count, market price |
| [Tenderly](https://tenderly.co) | EVM transaction simulation, gas estimation, calldata decoding |
| [Moralis](https://moralis.com) | Wallet, token, NFT analytics across EVM and Solana |
| [Hive Archive](https://mcp.hiveintelligence.xyz) | Cross-venue crypto derivatives history from Hive's own archive store: settled funding rates across 33 CEX and DEX venues since November 2023, basis since March 2025, open interest and liquidations since April 2025, and long/short ratio since March 2026 |
| [RWA Perps](https://mcp.hiveintelligence.xyz) | Cross-venue tokenized real-world-asset perp funding and markets (Hyperliquid HIP-3 builder dexes, Ostium, Avantis, Lighter, Extended) with mechanism-true normalization fields |
## How routing works
You do not choose a provider. Ask for a price and Hive decides whether that means CoinGecko,
Alchemy, or CCXT based on the asset, the venue, and which sources are healthy right now.
The `provider` field in every receipt tells you which one answered, so the same question can
legitimately cite different sources on different days.
## Managed keys
Hive holds the upstream credentials. You do not sign up with CoinGecko or Alchemy separately,
and you do not manage their rate limits.
That covers every source in the table above that needs a credential at all. The RWA Perps
venues need none: Hive reads their official public endpoints keylessly. If a source needs a
credential Hive does not hold, calls to it return `missing_key` rather than failing silently,
so you can tell the difference from an outage.
## Only official endpoints
Every provider above is accessed through its documented, official API. Hive does not scrape
sites or use reverse-engineered private endpoints, which means coverage is narrower in places
than it could be, and considerably more stable.
## What Hive deliberately does not cover
Hive serves raw datapoints, not opinions, and skips most of what your model can already
search for. There are no social sentiment scores and no trend summaries. Those are things an
LLM with web access handles better, and wrapping them in an API would add a stale layer
between your agent and the source.
News is carried, because CoinGecko already publishes it as structured data rather than as a
page to be scraped: `get_news` returns its article feed, filterable by coin, and
`get_coin_insights` returns its research notes on an Enterprise plan.
# How Hive works
Source: https://docs.hiveintelligence.xyz/concepts/how-it-works
Why your agent finds the right tool without you wiring anything.
Hive exposes 525 callable tools. If a client loaded all of them at once, the tool list alone
would crowd out the conversation. So the root endpoint stays small and routes instead.
## The root endpoint is deliberately small
When your agent connects to `https://mcp.hiveintelligence.xyz/mcp`, it sees eight tools: five
workflow primitives and three hero tools for the most common questions.
The three hero tools answer directly:
| Tool | Question it answers |
| ---------------------- | ----------------------------------- |
| `get_token_price` | What is this asset worth right now? |
| `check_token_safety` | Is this contract risky? |
| `get_wallet_portfolio` | What does this address hold? |
Everything else is reached through discovery.
## Discovery, schema, execution
For anything beyond the hero tools, agents follow three steps:
`search_tools` takes a plain description of the task and returns the tools that match,
scoped to the relevant category. It also returns any workflow that fits, which is usually
the better thing to follow.
`get_api_endpoint_schema` returns the exact parameters, types, and defaults, so the agent
builds a valid call instead of guessing argument names.
`invoke_api_endpoint` executes the call and returns a bounded, typed response with the
receipt attached.
Your agent does this on its own. You do not register tools, maintain a manifest, or update
anything when Hive's catalog changes.
## Workflows do the sequencing
Finding a tool is not the same as knowing what to do with it. Hive ships 13 workflows covering
the jobs people actually ask an agent to do, and each one carries the route: which tool runs
first, what to fall back to when a provider is rate-limited, how many billable calls the job
should take, and when to stop.
`search_tools` returns matching workflows next to matching tools. Following one is what stops
an agent guessing an identifier it could have resolved, or fetching three more pages after it
already had the answer.
All 13, and what a route carries.
## Why not load everything at once
Two reasons. A 525 tool list eats context that should hold the actual problem, and it makes
selection harder: the more similar tools an agent sees at once, the more often it picks the
wrong one. Narrowing by task first produces better calls.
If you want a middle ground, connect to a single category endpoint. Your agent then sees only
that category's tools, with no discovery step. The trade is flexibility for a shorter list.
## Bounded by default
Responses respect `limit`, `page`, `per_page`, and `offset`, and Hive caps response size
regardless. A query that would return thousands of rows comes back paginated rather than
flooding your agent's context.
## Where the data comes from
Hive normalizes 15 data sources behind one interface, twelve of them external providers. Your
agent asks for a price; Hive decides whether that means CoinGecko, Alchemy, or CCXT, and tells
you which one it used.
What each provider covers.
# Limits and credits
Source: https://docs.hiveintelligence.xyz/concepts/limits
How the anonymous lane, credits, and rate limits work, and what happens when you hit them.
Hive stops rather than billing you for overage. Plans are fixed subscriptions with a hard
cap, so a runaway agent produces an error, not an invoice.
## The anonymous lane
Without an account you get 25 material calls per IP per day, resetting at 00:00 UTC.
Discovery calls do not count, and neither does `report_feedback`. Your agent can list tools
and read schemas as often as it needs while working out what to call. Every other call is one
allowance call, taken when the request is accepted and given back if the call fails, bad
arguments included, so only calls that succeed count toward the 25. `GET /api/v1/quota` and
`hive doctor` show what is left without spending any.
## Credits
Signed-in accounts draw from a monthly credit wallet instead. Credits are tracked on your
account, not per key, so creating extra keys does not create extra allowance.
Every tool costs one credit; discovery tools, category listings and `report_feedback` cost
none. On a keyed lane the credit is debited only after your arguments validate and the
provider is reachable, so a validation error costs nothing. If the call then fails, the credit
is refunded and the receipt carries a warning saying so, which means only a call that succeeds
costs a credit. A scheduled monitor run is refunded the same way when it errors or every tool
call in it fails. Each receipt says what happened in `credit_cost`, `credits_used` and
`credits_remaining` (see [receipts](/concepts/receipts#what-the-call-cost)).
| Plan | Monthly credits | Rate limit | Active keys |
| ---------- | --------------- | ---------- | ----------- |
| Free | 10,000 | 100/min | 5 |
| Starter | 100,000 | 300/min | 5 |
| Pro | 500,000 | 500/min | 10 |
| Enterprise | Custom | Custom | Custom |
Current pricing lives at
[hiveintelligence.xyz/pricing](https://www.hiveintelligence.xyz/pricing).
## What happens at the cap
Requests fail with a quota error naming the cause. Nothing is billed beyond your subscription,
and no request silently degrades to worse data.
The credit error tells you to upgrade or wait for the next cycle. On the MCP endpoint it also
names the exact instant your credits refill, taken from your billing cycle, and sends
`Retry-After: 60`. On the REST API the same error carries `X-Quota-Remaining` but no
`Retry-After` and no refill instant, so read your cycle end from dashboard usage instead.
Your credits reset on a rolling cycle, not on the first of the month. The cycle is anchored to
when your account was created, or to your most recent payment if you are on a paid plan. You
can see the current balance and cycle end on
[dashboard usage](https://www.hiveintelligence.xyz/dashboard/usage).
## Rate limits
Rate limits are per minute and per plan. Exceeding one returns a rate limit error with
headers telling you when to retry. Agents should back off rather than retrying immediately.
Rate limits and credits are separate: you can be well inside your monthly credits and still
hit a per minute limit during a burst.
## Designing agents around this
A few habits that keep agents inside the caps:
* Use `limit` and `page` rather than pulling full result sets you will not read.
* Cache results your workflow reuses within a single task, instead of re-fetching per step.
* Prefer a category endpoint when a workflow only touches one domain, so discovery calls stay
cheap and focused.
# Receipts
Source: https://docs.hiveintelligence.xyz/concepts/receipts
Every material answer says where it came from, when it was fetched, and whether the source was healthy.
An agent that reports a number without a source is asking you to trust it. Hive attaches
provenance to every material response so the number can be checked.
## The three fields
The source that served this data, written as a display name: for example `CoinGecko`,
`GoPlus`, or `CCXT`.
When Hive routes the same question to different providers on different days, the receipt
changes with it.
When the data was retrieved from that provider. Compare it against your own clock to decide
whether a figure is fresh enough to act on.
Whether the provider was healthy for this call. A degraded or partially available provider
says so rather than returning a number that looks authoritative.
## What the call cost
Since 1.7.0 the same receipt says what the call cost, on every surface:
The static price of the tool. Discovery tools, category listings and `report_feedback` are
0; every other tool is 1. There is no price list beyond this.
What this call cost: the `credit_cost` when the call succeeded, and 0 when it did not. A
call stopped by argument validation or a gate never reached the provider and was never
charged; a call that failed after that had its credit refunded, and `warnings` says so. The
keyless lane works the same way with its daily allowance. Refunds began in 1.9.0; before
that, a call that reached a provider cost its credit even when the provider failed.
The balance after this call: credits on a keyed lane, calls left today on the keyless lane.
`null` means an unlimited plan. Absent when the lane has no notion of a balance, for
example local `stdio`.
Errors add `doc_url`, an anchor on the [errors page](/reference/errors) for the exact code, next
to `cause` and `next_action`.
## Why this matters in practice
An agent doing token diligence might pull a price, a liquidity figure, and a contract risk
score from three different providers within a few seconds of each other. Without receipts,
the summary reads as one confident answer. With them, you can see that the price is four
seconds old, the liquidity figure is two minutes old, and the risk score came back while its
provider was degraded.
That last case is the one worth designing for. Hive would rather tell you a source was
struggling than quietly serve you a stale number.
## Normalization is a field, never a filter
When Hive knows something is off about a datapoint, it says so in the response instead of
dropping the row. You will see fields like:
| Field | Meaning |
| ------------------- | ---------------------------------------------------------------------- |
| `is_delisted` | The asset is no longer actively traded on the venue |
| `is_price_suspect` | The price diverges enough from other sources to be worth a second look |
| `funding_mechanism` | How this venue calculates funding, since venues differ |
Your agent decides what to do with a suspect price. Hive does not decide for you by hiding it.
## Reading receipts in your agent
Ask for them explicitly and models will surface them:
> Get the price of SOL and tell me which provider it came from and how old it is.
For workflows where provenance matters every time, the [agent skills](/skills) build receipt
citation into the prompt so you do not have to ask.
# Workflows
Source: https://docs.hiveintelligence.xyz/concepts/workflows
The 13 task routes Hive uses to turn a question into a bounded sequence of calls.
Discovery finds you a tool. A workflow tells your agent what to do with it.
Hive groups its catalog into 13 workflows. Each one covers a job someone actually asks an
agent to do, and carries the sequence of calls that answers it: which tool runs first, what to
fall back to when a provider is unavailable, how many billable calls the job should take, and
when to stop.
When your agent calls `search_tools`, it gets matching workflows alongside matching tools. Most
agents use the workflow.
## Why this exists
A catalog of 525 tools answers "what can I call". It does not answer "what should I call, in
what order, and when am I done".
Left to work that out alone, an agent tends to make the same mistakes: it calls a tool without
the identifier that tool needs, it keeps fetching after it already has the answer, or it hits a
rate-limited provider and stops rather than trying the alternative. Workflows carry that
knowledge so the agent does not have to rediscover it every session.
## The 13 workflows
| Workflow | What it answers | Routes |
| ------------------------------ | ---------------------------------------------------------------- | ------ |
| Market Research | Price, market cap, OHLC, exchanges, order books, derivatives | 2 |
| Token Diligence | One token across metadata, liquidity, holders, DEX pairs, risk | 2 |
| Wallet Investigation | Balances, transfers, profit and loss, NFTs, DeFi positions | 2 |
| Security Risk | Contract, approval, address, dApp and phishing checks | 3 |
| On-chain DEX and Pool Analysis | Pools, pairs, liquidity, trades, trending DEX activity | 2 |
| DeFi Protocol Analysis | TVL, fees, revenue, stablecoins, bridges, yields | 4 |
| NFT Research | Ownership, metadata, floors, sales, rarity, spam checks | 2 |
| Network Infrastructure | Chain state, gas, blocks, receipts, transaction status | 2 |
| Solana Analysis | Solana wallets, SPL accounts, parsed transactions, priority fees | 3 |
| RWA Perp Analysis | Tokenized stocks, ETFs, commodities and FX across five venues | 3 |
| Stateful Monitoring | Durable monitors that persist between agent sessions | 3 |
| Search and Discovery | Routing a vague request to the right workflow and tools | 2 |
That is 32 routes in total. A workflow has more than one route when the same subject gets asked
about in different ways: Security Risk separates a contract check from an approval check from a
transaction preflight, because those need different inputs and different tools.
## What a route carries
Take the spot snapshot route in Market Research, which answers questions like "what is BTC
trading at, and is there enough liquid venue coverage?".
When the route applies. Here: a current price, market context, or a quick asset check.
What the agent must resolve before calling anything. Here: an exact asset id and a quote
currency. Half of all bad tool calls come from guessing an identifier instead of resolving
it first.
Each step names a phase, a purpose, a primary tool, and a fallback. The spot snapshot
starts by fetching the current observation with `get_price`.
`maxMaterialCalls` caps the billable calls the route should need. Twenty-six of the 32
routes allow 4. The six that allow 2 or 3 are the cheaper jobs: both discovery routes, all
three RWA routes, and the chain protocol landscape route in DeFi.
What "done" looks like, so the agent returns an answer instead of gathering more.
## Fallbacks are conditional, not automatic
Most steps name a fallback tool, and every fallback carries the condition that permits it:
> Use only when the primary is unavailable, gated, rate-limited, stale for the decision, or
> lacks the required identifier coverage.
Eleven of the 82 route steps have no substitute at all. Their condition reads instead: "No
automatic substitute. Stop this route and report the missing phase instead of guessing or
broadening scope."
Your agent does not silently swap providers to get a nicer-looking answer. When it does fall
back, the receipt names the provider that actually served the data, so you can see the
substitution rather than infer it.
## Reading them yourself
`search_tools` returns workflows at three levels of detail, and defaults to the smallest:
| Detail | What you get |
| ---------- | ------------------------------------------------------------------ |
| `compact` | Purpose, outcome, required identifiers, providers, matching routes |
| `standard` | Adds tags, runtime statuses, and the execution policy |
| `full` | Adds the output schema and the full tool coverage list |
Use `full` only when you need the output schema. On a typical query it returns close to five
times the payload of `compact`, and that context is usually better spent on the problem.
```bash theme={null}
hive tools search "wallet"
```
The `hive://toolsets` resource lists all 13 without a tool call, which is useful when you want
to read them once and cache the result.
## When to skip them
Workflows help when the shape of the job is unclear. They add nothing when it is not.
If you already know the tool you want, call `invoke_api_endpoint` with its name and skip
discovery. If every question you ask lives in one category, connect to that category endpoint
instead and your agent sees those tools directly, with no discovery step at all.
The discovery loop these routes sit on top of.
# DeFi yield
Source: https://docs.hiveintelligence.xyz/guides/defi-yield
Compare pools on more than the headline APY.
Headline APY is the least reliable number in DeFi. It is usually annualized from a short
window, often includes incentive emissions that are about to end, and says nothing about
whether you can exit.
## Ask
> Find USDC yield opportunities above 5% APY. For each, show TVL, what the yield is actually
> composed of, and how long the pool has existed.
## What to compare
| Signal | Why it matters |
| ------------------ | ----------------------------------------------------------------------------------- |
| TVL | A shallow pool can be drained or exited before you can react, whatever the APY says |
| Base vs reward APY | Base yield persists; emissions stop |
| Pool age | New pools have no track record and higher contract risk |
| Protocol TVL trend | A protocol losing TVL fast is a different risk than a stable one |
| Chain | Where the pool lives changes both bridging cost and risk |
Where the upstream source separates base yield from incentive rewards, that split is the
single most useful signal when a headline number looks too good.
## Then check the contract
A yield opportunity is also a contract you are about to approve. Run the
[token security](/guides/token-security) checks on the pool token and the protocol before
committing, and look at outstanding approvals afterward.
## What this cannot tell you
Impermanent loss is not in the APY. For volatile pairs, a high APY can still lose against
simply holding. Hive gives you the inputs; the model is yours.
# Guides
Source: https://docs.hiveintelligence.xyz/guides/index
Worked crypto workflows, from token diligence to wallet forensics.
Each guide walks one real task end to end: what to ask, which tools answer it, and how to
read the result.
Decide whether a contract is safe before interacting with it.
Price, liquidity, and derivatives context for an asset.
What an address holds, and what it has been doing.
Compare pools on more than headline APY.
Feed live market state into an automated strategy.
## Before you start
All five assume Hive is connected. If it is not, [quickstart](/quickstart) takes about two
minutes.
Several go faster with the matching [skill pack](/skills) installed, since the skill already
knows the route and you can ask the question directly instead of describing the steps.
# Market intelligence
Source: https://docs.hiveintelligence.xyz/guides/market-intelligence
Build a full picture of an asset: spot, liquidity, derivatives, and where it trades.
A price on its own is thin. What you usually want is whether that price is real: how deep the
book is, where it trades, and what the derivatives market thinks.
## Ask
> Give me a full market picture for SOL: spot price, where it trades, order book depth, and
> current funding rates across venues. Cite each source.
## What to pull
| Question | Where it comes from |
| ------------------------------- | --------------------------------------------------------------------------------------- |
| What is it worth? | Spot price across aggregated sources |
| Is that price trustworthy? | Cross-venue comparison, plus the `provider` and `fetched_at` that every receipt carries |
| Can I trade size? | Order book depth and pool liquidity |
| What do derivatives say? | Funding rates, open interest, basis |
| Where does volume actually sit? | Exchange-level volume breakdown |
## Funding rates across venues
Hive aggregates funding across 33 CEX and DEX venues, with history back to November 2023.
That matters because a single venue's funding rate tells you about that venue, not the market.
Venues also settle funding on different intervals. Every archive funding row carries the venue,
the settled rate and `interval_hours`, plus a `funding_annualized` derived from that row's own
interval, so you can line up an 8-hour settlement against a 1-hour one instead of averaging
incompatible numbers.
## Watch for
**Stale prices on thin assets.** A token that has not traded in hours still returns its last
price. `fetched_at` tells you how old that is.
**Delisted assets.** `is_delisted` marks assets no longer actively traded. Without checking
it, an agent reports a price for something you cannot buy.
**Suspect prices.** On tokenized real-world-asset perps, `is_price_suspect` flags a mark more
than 2% off the cross-venue median when at least three venues quote the same underlying. Below
that, the row carries `price_suspect_basis: "insufficient_venues"` instead. For crypto spot,
compare venues yourself and read `runtime_status`, `source` and `origin_source` on the receipt.
# Token security
Source: https://docs.hiveintelligence.xyz/guides/token-security
Check whether a token contract is safe to interact with before you touch it.
The failure mode this prevents: an agent looks up a token's price, finds a number, and
reports that it is worth something. The contract turns out to be a honeypot you can buy but
never sell.
## Ask
> Check whether the token at 0x6B175474E89094C44Da98b954EedeAC495271d0F on Ethereum is safe
> to interact with. Show the risk signals and cite your sources.
With `hive-token-diligence` installed, that is the whole prompt. Without it, ask your agent
to resolve the token first, then run a security scan, then check holder concentration.
## What gets checked
Confirm the address maps to the token you think it does. Symbol collisions are common and
an agent that skips this step will happily analyze the wrong contract.
Honeypot behavior, mint authority, ownership renouncement, transfer restrictions, and
proxy upgradeability. GoPlus provides most of these signals.
Depth, which pools hold it, and whether liquidity is locked. A clean contract with two
thousand dollars of liquidity is still untradeable at size.
If a handful of wallets hold most of the supply, a clean scan does not mean much.
## Reading the answer
Three questions decide whether the result is usable:
* **Which provider ran the scan**, since coverage differs by chain. A risk score for a chain
the provider barely indexes is weak evidence.
* **How old the data is.** Contract ownership can change. A scan from an hour ago is not a
statement about now.
* **Whether `runtime_status` was healthy.** A degraded security provider is the one case
where you should re-run rather than trust the answer.
## What a clean result does not tell you
A contract that passes every automated check can still be a rug. These signals catch
mechanical traps, not intent. Treat a clean scan as the absence of known red flags, not proof
of safety, and size positions accordingly.
# Trading bot
Source: https://docs.hiveintelligence.xyz/guides/trading-bot
Feed live, sourced market state into an automated strategy.
Hive serves data. It does not place trades, hold funds, or give financial advice. Execution,
risk limits, and every trading decision remain entirely yours.
## The shape
A bot using Hive typically runs on a schedule rather than conversationally:
No browser in a cron job, so use an API key from your secret manager. See
[authentication](/authentication).
Prices, funding, open interest, liquidity. Keep the set small; every call costs credits
and time.
This is the step people skip. Reject data that is too old or came back with a degraded
`runtime_status`, rather than trading on it.
Your venue integration handles the order. Hive is not in that path.
## Use the CLI for the plumbing
```bash theme={null}
hive tools call get_token_price --args '{"token":"BTC"}' --json
```
`--json` prints an envelope with `ok`, `data`, and `meta`, where `meta` carries the provider
and runtime status. The CLI has a built-in `--jq` filter if you want to pull one field out
without piping:
```bash theme={null}
hive tools call get_token_price --args '{"token":"BTC"}' --jq '.price'
```
Exit codes are stable enough to gate on.
## Staying inside limits
Rate limits are per minute and credits are per month, and a bot can exhaust either. Practical
habits:
* Poll on the interval your strategy actually needs, not the fastest one available.
* Batch what can be batched rather than looping single lookups.
* Handle the quota error properly. Hive hard stops rather than billing overage, so a bot that
ignores the error simply trades on nothing.
## The failure mode worth designing for
Data can be stale or degraded without being wrong-looking. A bot that acts on any number it
receives will eventually act on a price fetched during a provider outage. Gate on `fetched_at`
and `runtime_status` explicitly, and treat a failed check as a reason to skip the cycle rather
than to guess.
# Wallet analysis
Source: https://docs.hiveintelligence.xyz/guides/wallet-analysis
Work out what an address holds and what it has been doing, across chains.
## Ask
> Analyze 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045. What does it hold across chains, what
> has it been doing recently, and are there any risky approvals outstanding?
## What a full picture includes
Native and token balances per chain. An address is rarely on one chain, and a
single-chain answer will understate holdings.
Collections held, with floor prices where they exist. Floors are indicative, not
liquidatable value.
Supplied, borrowed, staked, and LP positions. These often hold more value than the raw
token balance suggests.
Transfers and swaps, which is where behavior shows up: accumulation, distribution, or a
wallet quietly exiting.
Outstanding token approvals, which is the security half. An old unlimited approval to a
since-compromised contract is a live risk regardless of what the wallet holds.
## Solana
Solana has its own account model, so ask specifically for SPL token accounts and Digital
Asset Standard assets. `hive-solana-analysis` handles parsed transactions and priority fees
in a way generic EVM tooling will not.
## Interpreting the result
**Portfolio value is an estimate.** It is composed from per-asset prices at slightly
different fetch times, and thin tokens can be marked at prices you could not realize.
**Absence is not proof.** If a chain is not covered for an asset type, the answer is
incomplete rather than zero. Ask which chains were actually checked.
**Labels are not identity.** An address associated with an entity in one dataset is not
confirmation that entity controls it today.
# Hive Intelligence
Source: https://docs.hiveintelligence.xyz/index
Live crypto market data for AI agents, with the source and age of every answer attached.
Hive is a crypto data layer built for AI agents. You add one endpoint to your agent, and it
can look up prices, wallet balances, DeFi positions, NFT activity, contract risk, and
derivatives from live sources instead of answering from training data.
Every material answer carries a receipt: which provider served it, when the data was
fetched, and whether that provider was healthy at the time. Your agent can quote the number
and cite where it came from.
Ask your first live question. No account, no key.
Claude, Cursor, VS Code, ChatGPT, and six more.
Discovery, schemas, and bounded execution.
Ten categories, 525 callable tools.
## Three ways to use Hive
**MCP** is the main surface. Add `https://mcp.hiveintelligence.xyz/mcp` to any MCP client
and your agent discovers Hive's tools on its own.
**The CLI** runs the same catalog from a terminal, which is useful for scripts, cron jobs,
and checking that credentials work.
**Agent skills** are 17 installable workflow packs that teach an agent how to run a whole
task, like token diligence or wallet investigation, rather than a single call.
## What you can ask
Once Hive is connected, questions like these resolve against live data:
* What is Bitcoin trading at right now, and where did that price come from?
* Is this token contract safe to interact with?
* What does this wallet hold across chains?
* Which pools on Base have the deepest liquidity for this pair?
* What are the current funding rates across perp venues?
## Start without an account
The anonymous lane covers 25 material calls per IP each day, resetting at 00:00 UTC.
Discovery calls do not count against it. That is enough to connect a client, ask real
questions, and decide whether Hive belongs in your stack before you sign up for anything.
Two minutes, no signup.
# ChatGPT
Source: https://docs.hiveintelligence.xyz/install/chatgpt
Add Hive to ChatGPT as a custom app.
Custom apps are available on eligible Business, Enterprise, and Edu workspaces. Personal
ChatGPT accounts cannot add custom MCP servers today. This remains a beta surface, so the
exact menu path moves from time to time.
## Create the app
1. Open **Settings > Apps** and create a new app in developer mode.
2. Give it the endpoint:
```
https://mcp.hiveintelligence.xyz/mcp
```
3. Choose **OAuth** for authentication.
4. Scan tools from the server.
5. Complete authorization in the browser.
## Verify
Start a new chat, enable the Hive app, and ask for a live price. ChatGPT shows the tool call
before it answers.
## Backend use instead
If you are calling the OpenAI Responses API from your own backend rather than using the
ChatGPT interface, point the API at Hive's endpoint with a bearer key instead of OAuth. See
[authentication](/authentication).
# Claude Code
Source: https://docs.hiveintelligence.xyz/install/claude-code
Add Hive to Claude Code with one command.
## Add the server
```bash theme={null}
claude mcp add --transport http hive https://mcp.hiveintelligence.xyz/mcp
```
That is the whole setup. Claude Code stores the server in your config and opens browser
authorization the first time it connects.
## Verify
```bash theme={null}
claude mcp list
```
You should see `hive` listed and connected. If it says it needs authentication, run:
```bash theme={null}
claude mcp login hive
```
`claude mcp login` needs an interactive terminal. By default it opens a browser; over SSH or
in a headless shell, `claude mcp login hive --no-browser` prints the authorization URL and
waits for you to paste the redirect back. Neither form completes inside a CI job.
## Ask something
Start a fresh Claude Code session, then:
> What is Ethereum trading at? Use Hive.
The answer should name a provider and a fetch time.
## Headless use
For CI or a script where no browser is available, skip OAuth and use a key:
```bash theme={null}
claude mcp add --transport http hive https://mcp.hiveintelligence.xyz/mcp \
--header "Authorization: Bearer $HIVE_API_KEY"
```
Keep the key in an environment variable. See [authentication](/authentication).
# Claude Desktop
Source: https://docs.hiveintelligence.xyz/install/claude-desktop
Connect Hive to Claude Desktop through Settings, Connectors.
## Add the connector
1. Open Claude Desktop and go to **Settings > Connectors**.
2. Choose **Add custom**, then **Web**. The Web option is what adds a remote server rather
than a local extension.
3. Paste the endpoint:
```
https://mcp.hiveintelligence.xyz/mcp
```
4. Approve the connection when Claude opens your browser.
Claude Desktop stores the credential itself. Nothing goes in a config file by hand.
## Verify
Start a new conversation and ask:
> What is the current price of Bitcoin? Use Hive.
If Claude answers with a provider name and a timestamp, the connector is live. If it answers
from memory with no source, the server did not load. Quit Claude Desktop fully and reopen it,
then check **Settings > Connectors** again.
## Refreshing the tool list
Claude caches the tool list per connection. After Hive ships new tools, disconnect and
reconnect the connector, or restart Claude Desktop, to pick them up.
# Codex CLI
Source: https://docs.hiveintelligence.xyz/install/codex
Add Hive to Codex CLI with mcp add and login.
## Add and authorize
```bash theme={null}
codex mcp add hive --url https://mcp.hiveintelligence.xyz/mcp
codex mcp login hive
```
The login step opens a browser. Approve the connection there and Codex stores the
credential.
If `codex mcp add` rejects `--url`, your Codex build predates remote HTTP MCP support. Run
`codex update` and try again.
## Verify
```bash theme={null}
codex mcp list
```
`hive` should appear as connected. Then start a session and ask for live data.
`codex mcp login` needs an interactive terminal.
## Headless use
Codex keeps its MCP servers in `~/.codex/config.toml` under `mcp_servers`. Where no browser is
available, point Codex at an environment variable rather than writing a key to disk:
```toml theme={null}
[mcp_servers.hive]
url = "https://mcp.hiveintelligence.xyz/mcp"
bearer_token_env_var = "HIVE_API_KEY"
```
If you need the key inline instead, use `http_headers`:
```toml theme={null}
[mcp_servers.hive]
url = "https://mcp.hiveintelligence.xyz/mcp"
http_headers = { Authorization = "Bearer YOUR_HIVE_API_KEY" }
```
See [authentication](/authentication) for where to get a key.
# Cursor
Source: https://docs.hiveintelligence.xyz/install/cursor
Add Hive to Cursor through mcp.json.
## Add the server
Open **Settings > MCP Servers > Add Server**, or edit `~/.cursor/mcp.json` directly:
```json theme={null}
{
"mcpServers": {
"hive": {
"url": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
Cursor discovers OAuth from the URL and opens a browser when it first connects. No secret
belongs in this file.
## Verify
Restart Cursor, then ask in chat:
> Use Hive to check whether 0x6B175474E89094C44Da98b954EedeAC495271d0F is safe.
You should see Cursor call a Hive tool before answering.
## If tools do not appear
Cursor reads `mcp.json` at startup. Quit and reopen it after editing. If the server shows
but has no tools, open the MCP panel and refresh it so Cursor re-runs discovery.
# Gemini CLI
Source: https://docs.hiveintelligence.xyz/install/gemini-cli
Add Hive to Gemini CLI through settings.json.
## Add the server
Edit `~/.gemini/settings.json`:
```json theme={null}
{
"mcpServers": {
"hive": {
"httpUrl": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
Gemini CLI uses `httpUrl` for a streamable HTTP server like Hive. It also accepts `url`,
but that selects its SSE transport, which is not what you want here. `serverUrl` is a
Windsurf key and will not work.
Complete OAuth in the browser when the server first connects.
## Verify
Restart the CLI and ask for a live price. If the server does not load, check the JSON parses
and that you used `httpUrl`.
# Compatible MCP clients
Source: https://docs.hiveintelligence.xyz/install/generic
Connect any MCP client that speaks Streamable HTTP.
Hive implements the Model Context Protocol over Streamable HTTP. Any compliant client can
connect, whether or not it has a guide here.
## What to give your client
| Setting | Value |
| ------------- | --------------------------------------- |
| Endpoint | `https://mcp.hiveintelligence.xyz/mcp` |
| Transport | Streamable HTTP |
| Authorization | OAuth 2.1 from the URL, or a bearer key |
Most clients want a JSON block shaped roughly like this:
```json theme={null}
{
"mcpServers": {
"hive": {
"url": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
The key names vary by client. Windsurf wants `serverUrl`, VS Code wants `servers` with
`"type": "http"`, and Gemini CLI wants `httpUrl`. Check your client's own MCP docs for which
it expects.
## Headless clients
If your client cannot open a browser, authenticate with a key instead:
```
Authorization: Bearer YOUR_HIVE_API_KEY
```
Create a key at [dashboard keys](https://www.hiveintelligence.xyz/dashboard/keys) and read
it from an environment variable rather than committing it.
## Category endpoints
The root endpoint returns a compact set of tools and routes your agent to the rest. If you
want a narrower surface, connect to one category endpoint instead, for example:
```
https://mcp.hiveintelligence.xyz/hive_market_data/mcp
```
Every category and its endpoint is listed in [tools](/tools).
# Grok
Source: https://docs.hiveintelligence.xyz/install/grok
Add Hive to Grok through connectors.
## Add the connector
1. Go to [grok.com/connectors](https://grok.com/connectors).
2. Choose **New Connector**, then **Custom**, and enter the endpoint:
```
https://mcp.hiveintelligence.xyz/mcp
```
3. Choose OAuth and complete authorization in the browser.
## Verify
Start a new conversation and ask Grok for a live crypto price using Hive. The response
should cite a provider rather than answering from training data.
If your organization hides Custom connectors, an admin has to allow Hive before the
option appears.
# Install Hive
Source: https://docs.hiveintelligence.xyz/install/index
Connect Hive's MCP endpoint to Claude, Cursor, VS Code, ChatGPT, and six other clients.
Every client connects to the same endpoint:
```
https://mcp.hiveintelligence.xyz/mcp
```
What differs is where the config lives and what the file looks like. Pick your client.
## The eleven supported clients
Most of these handle OAuth themselves: you add the URL, they open a browser on first connect,
and they store the credential outside your config file, so no secret goes in `mcp.json`.
Two work differently. ChatGPT has no config file at all and is added through a plan-gated
developer surface, and Qwen Code expects a bearer token in `~/.qwen/settings.json`, because its
OAuth configuration needs a static client id that Hive does not issue. Their pages cover both.
One command in your terminal.
Settings, Connectors, paste the URL.
`~/.cursor/mcp.json`
`~/.codeium/windsurf/mcp_config.json`
`.vscode/mcp.json`, version 1.102 or newer.
Business and Enterprise workspaces.
Connectors on grok.com.
`codex mcp add`, then log in.
`~/.gemini/settings.json`
`kimi mcp add`, then authorize.
`~/.qwen/settings.json`
## Anything else
If your client speaks MCP over Streamable HTTP, it will work. See
[compatible MCP clients](/install/generic) for the shape most clients expect and what to do
when yours needs a key instead of OAuth.
## After you connect
Start a fresh session so the client re-reads its server list, then ask a question that needs
live data. [Quickstart](/quickstart) has a couple that make it obvious whether the connection
is working.
# Kimi Code CLI
Source: https://docs.hiveintelligence.xyz/install/kimi-cli
Add Hive to Kimi Code CLI over remote MCP, with browser authorization.
MCP is a Kimi Code CLI feature. The Kimi chatbot at kimi.com has no connector surface, so
this page is the way to use Hive with Kimi.
## Add the server
```bash theme={null}
kimi mcp add --transport http --auth oauth hive https://mcp.hiveintelligence.xyz/mcp
kimi mcp auth hive
```
`kimi mcp auth` opens a browser. Approve the connection there and Kimi stores the credential
outside your config file, so no secret goes on disk.
## Headless use
Where no browser is available, pass a key in the header instead:
```bash theme={null}
kimi mcp add --transport http hive https://mcp.hiveintelligence.xyz/mcp \
--header "Authorization: Bearer YOUR_HIVE_API_KEY"
```
See [authentication](/authentication) for where to get a key.
## Verify
```bash theme={null}
kimi mcp list
```
`hive` should appear as connected. Then start a session and ask for a live price.
Kimi Code CLI keeps its servers in `~/.kimi-code/mcp.json` under `mcpServers`, or in
`.kimi-code/mcp.json` in the working directory for a project-scoped server.
# Qwen Code
Source: https://docs.hiveintelligence.xyz/install/qwen-code
Add Hive to Qwen Code over remote MCP with a bearer token.
## Add the server
```bash theme={null}
qwen mcp add --transport http hive https://mcp.hiveintelligence.xyz/mcp \
--header "Authorization: Bearer YOUR_HIVE_API_KEY"
```
See [authentication](/authentication) for where to get a key.
## Or edit settings.json
Add an `mcpServers` block to `~/.qwen/settings.json`, or to `.qwen/settings.json` in the
project root:
```json theme={null}
{
"mcpServers": {
"hive": {
"httpUrl": "https://mcp.hiveintelligence.xyz/mcp",
"headers": {
"Authorization": "Bearer YOUR_HIVE_API_KEY"
}
}
}
}
```
Qwen Code uses `httpUrl` for a streamable HTTP server like Hive. It also accepts `url`, but
that selects its SSE transport, which is not what you want here. This is the same split
Gemini CLI has.
Qwen Code can do OAuth, but its configuration expects an explicit `oauth.clientId` and
`oauth.tokenUrl`. Hive issues clients by dynamic registration rather than handing out a
static id, so the bearer token above is the supported path today.
## Verify
```bash theme={null}
qwen mcp list
```
`hive` should appear. Then start a session and ask for a live price.
# VS Code
Source: https://docs.hiveintelligence.xyz/install/vs-code
Add Hive to VS Code through .vscode/mcp.json.
Requires VS Code 1.102 or newer.
## Add the server
Create `.vscode/mcp.json` in your project root:
```json theme={null}
{
"servers": {
"hive": {
"type": "http",
"url": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
VS Code uses `servers`, not `mcpServers`, and needs the explicit `"type": "http"`.
VS Code opens browser authorization on first use and stores the credential outside this
file, so `.vscode/mcp.json` is safe to commit.
## Verify
Reload the window, open Copilot Chat in agent mode, and ask for something live. Hive's tools
appear in the tool picker once discovery completes.
# Windsurf
Source: https://docs.hiveintelligence.xyz/install/windsurf
Add Hive to Windsurf through mcp_config.json.
## Add the server
Edit `~/.codeium/windsurf/mcp_config.json`:
```json theme={null}
{
"mcpServers": {
"hive": {
"serverUrl": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
Windsurf accepts both `serverUrl` and `url`. We use `serverUrl` because that is the field
name in Codeium's own documentation.
Windsurf opens browser authorization when the server first connects.
## Verify
Restart Windsurf and ask a question that needs live data. If nothing happens, check the MCP
panel for a load error on the `hive` entry.
# Quickstart
Source: https://docs.hiveintelligence.xyz/quickstart
Connect Hive to your AI client and get a live, sourced answer in about two minutes.
You do not need an account to try Hive. Add the endpoint, ask a question, read the receipt.
## Step 1: Add the endpoint
Pick your client. Every option below points at the same URL:
```
https://mcp.hiveintelligence.xyz/mcp
```
```bash theme={null}
claude mcp add --transport http hive https://mcp.hiveintelligence.xyz/mcp
```
Add this to `~/.cursor/mcp.json`:
```json theme={null}
{
"mcpServers": {
"hive": {
"url": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
Create `.vscode/mcp.json` in your project root. Requires VS Code 1.102 or newer.
```json theme={null}
{
"servers": {
"hive": {
"type": "http",
"url": "https://mcp.hiveintelligence.xyz/mcp"
}
}
}
```
Open **Settings > Connectors**, add a custom connector, and paste the endpoint URL.
Claude Desktop handles authorization in the browser.
Eleven clients have their own guide with the exact file path and config shape. See
[Install](/install) if yours is not above.
## Step 2: Ask something live
Start a fresh session so the client picks up the new server, then ask:
> What is the current price of Bitcoin? Use Hive.
The answer should name a provider and a timestamp. If it does, your agent is reading live
data instead of guessing from training.
Try a harder one:
> Check whether the token at 0x6B175474E89094C44Da98b954EedeAC495271d0F is safe to interact with.
## Step 3: Read the receipt
Material responses carry three fields worth checking:
Which upstream source served the data, for example CoinGecko or GoPlus.
When the data was retrieved. Stale data is labelled, not hidden.
Whether that provider was healthy for this call. A degraded provider says so.
This is the part that makes the number quotable. Your agent can say where it got a figure
and how old it is, which matters when someone acts on it.
## What you get without signing in
The anonymous lane allows 25 material calls per IP per day, resetting at 00:00 UTC.
Discovery calls, where the agent lists tools or reads a schema, do not count against that.
When you need more, [authentication](/authentication) covers OAuth for interactive clients
and API keys for headless ones.
## Next
Exact config for all eleven supported clients.
Why your agent finds the right tool on its own.
# Changelog
Source: https://docs.hiveintelligence.xyz/reference/changelog
Notable changes to the Hive MCP server, CLI, and skills.
A call that fails no longer costs anything. On a keyed lane the credit a failed call used is
refunded: the receipt reads `credits_used: 0`, `credits_remaining` shows the restored
balance, and `warnings` says the credit was refunded. On the keyless lane a failed call gives
its daily call back, including one rejected for bad arguments. A scheduled monitor run is
refunded when it errors or when every tool call in it fails.
Hive Archive responses now date each dataset from its own start. Funding settlements go back
to November 2023; basis starts in March 2025, open interest and liquidations in April 2025,
and the long/short ratio in March 2026. Earlier copy said every series went back to November
2023\.
Every vendor tool was run from production, and the failures that were Hive's own are fixed.
`alchemy_simulate_execution` sends its arguments in the order Alchemy expects,
`tenderly_suggest_gas_fee` calls the right gateway method, Tenderly gateway calls retry when
they are rate limited, DeFiLlama price charts accept a start and an end together, and
`hyperliquid_get_token_details` accepts a spot token name such as `HYPE`.
Alchemy's Solana DAS and Photon tools fall back to Helius when Alchemy's indexer is
unavailable. The response says so: `_hive.source` reads `fallback`, and a `_fallback` block
names the provider that answered.
Errors now carry the provider's own message, so a malformed address or an unsupported input
comes back as `invalid_input` rather than looking like an outage.
Twenty-one tools that fail on every call on Hive's current data plans are retired: five
CoinGecko Enterprise tools (supply charts and coin insights), seven DeFiLlama Pro tools
(derivatives volumes, categories, oracles, forks, and entities), three Helius wallet-identity
tools, two Alchemy bundle simulations, three CCXT current borrow-rate tools, and GoPlus Solana
pre-execution. Calling one returns `TOOL_RETIRED` with a working replacement. The catalog is
now 525 callable tools across ten categories.
Prediction markets return as a first-party category on Polymarket, not a resold feed: seven
keyless tools for market and event search, market-implied odds, CLOB order books, bounded
odds history, and a wallet's positions and activity, plus the `prediction_markets` task
toolset, the restored `hive-prediction-markets` skill pack, and the `prediction_market`
monitor kind. Kalshi is not covered, because its developer agreement requires prior written
authorization before its API data is shared with anyone else.
Four market-signals tools landed: `signals_get_fear_greed` (Crypto Fear and Greed, current
plus daily history), `signals_get_technical_indicators` (RSI, MACD, Bollinger, EMA and SMA
that Hive computes from CoinGecko candles and reports the candle interval for),
`signals_get_onchain_metrics` (daily Bitcoin hash rate, active addresses, transaction count
and price), and `defillama_get_hacks`.
Every receipt now says what the call cost: `credit_cost`, `credits_used`, and
`credits_remaining`, with a `doc_url` on every error. `report_feedback` is a free write that
works on the keyless lane, so an agent can report a gap without an account.
`GET /api/v1/quota` reads today's keyless allowance without spending one.
The CLI gained generated `--` flags on `hive tools call`, a parameter table in
`hive tools info`, `hive routing install|decline|remove` for the AGENTS.md routing block,
`hive feedback`, the `hive archive` namespace, and exit code 6 with no retry on every
allowance or quota code.
Skills are now led by one umbrella pack, `hive`, which picks the transport and loads the
rest. Eighteen packs ship. The catalog is 546 callable tools across ten categories and 15
providers.
The Codex.io provider is gone, and with it the Prediction Markets category, its category
endpoint, the `hive-prediction-markets` skill pack, and the `prediction_market` monitor kind.
Calls to a retired tool name return a classified not-found error that names the replacement.
CoinGecko gained the seven tokenized real-world-asset endpoints (`get_rwa_list`,
`get_rwa_markets`, `get_rwa_asset`, `get_rwa_tickers`, `get_rwa_market_chart`,
`get_rwa_issuers`, `get_rwa_issuer`), Hyperliquid gained `hyperliquid_get_outcome_deployer_limits`,
and Helius gained the Parsed Events API (`helius_get_parsed_events_transactions`,
`helius_get_parsed_events_transaction_history`). Eight Alchemy NFT tools that Alchemy retires
on 2026-09-30 were removed ahead of the sunset. The catalog is now 534 callable tools across
nine categories and 12 providers. `hive portfolio balance`, `hive portfolio history`, and
`hive network chains` now route through Alchemy and CoinGecko.
Hive is now an agent-focused product. The REST API remains as internal plumbing for the
CLI and dashboard, but it is no longer a documented product surface, and the SDK guides
have been retired.
Documentation moved here from the main site.
Added cross-venue derivatives history from 33 CEX and DEX venues: settled funding rates
back to November 2023, plus basis (from March 2025), open interest and liquidations (from
April 2025), and long/short ratio (from March 2026). This entry first said every series
went back to November 2023; only funding does.
`hive-intelligence` 1.4.0 is on npm and the hosted runtime serves it. It fixes
`hive auth login`, which previously failed on every attempt, and stops login minting a new
API key each time you sign in. Sign-in now also accepts GitHub and Google, and the email path
sends a 6-digit code as well as a link. `hive auth signup` and the `hive keys` group are
retired: manage keys in the dashboard. Run `hive upgrade` to move an existing install.
The `hive-intelligence` 1.3.0 release ships the CLI with `hive init --all --browser`, which
detects installed clients and writes their config for you.
Added 25 material calls per IP per day with no account, so Hive can be evaluated before
signup. Discovery calls do not count against the cap.
The root endpoint exposes eight tools rather than the full catalog: five workflow
primitives plus three hero tools. Everything else is reached through discovery.
# Errors
Source: https://docs.hiveintelligence.xyz/reference/errors
What Hive's errors mean and what to do about each one.
Hive writes errors for the model, not just the log. Each one names what went wrong and what
to do next, so an agent can recover without a human reading a stack trace.
## Authentication
| Error | Cause | Fix |
| ------------------ | ------------------------------------------- | ------------------------------------------------------- |
| Missing credential | A protected surface was called with no auth | Connect via OAuth, or send a bearer key |
| Invalid key | The key is wrong, disabled, or revoked | Check it in the dashboard; create a new one if disabled |
| Expired session | An OAuth credential lapsed | Reconnect the client |
Sending a key that is present but wrong returns a 200 with an error envelope rather than a
401\. This is deliberate and regression-tested: some MCP clients treat a 401 as a transport
failure and drop the connection instead of surfacing the message.
## Quota and rate
| Error | Cause | Fix |
| --------------------- | ---------------------------------------- | -------------------------------------------- |
| Anonymous cap reached | 25 material calls used for this IP today | Sign in, or wait for 00:00 UTC |
| Credits exhausted | Monthly allowance spent | Upgrade, or wait for the cycle to reset |
| Rate limited | Too many requests this minute | Back off and retry; do not retry immediately |
Credits and rate limits are independent. You can hit a per minute limit while well inside
your monthly credits.
## Tools and arguments
| Error | Cause | Fix |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Unknown tool (`TOOL_NOT_FOUND`, REST 404) | The name does not exist in the deployed catalog | Run `search_tools` with your task and retry with the exact name; the receipt's `next_action` says the same |
| Retired tool (`TOOL_RETIRED`, REST 410) | The name was removed in a release (for example the Codex-era tools retired on 2026-09-06) | Call the replacement named in the message with its own argument names. Never retry the retired name; it will not come back |
| Invalid arguments (`VALIDATION_ERROR`, REST 422) | Wrong shape, type, or a missing required field | Call `get_api_endpoint_schema` and rebuild the call. The hero tools also accept common aliases such as `token_address`, `contract_address`, `wallet`, and `network` |
| Unsupported chain | The tool does not cover that chain | Check the category page for coverage |
Most argument errors come from an agent guessing parameter names. Reading the schema first
avoids nearly all of them. All three carry `runtime_status: "invalid_input"` in the receipt:
the call is fixable by the caller, and retrying it unchanged will fail again.
## Provider and runtime
| Error | Cause | Fix |
| -------------------- | ------------------------------------------------------------------- | --------------------------------------------------------------- |
| Provider unavailable | The upstream source is down or not configured | Retry later; check `runtime_status` |
| Provider degraded | The source timed out or returned a 5xx, so it is unstable right now | Retry after a pause; treat any partial result as low confidence |
| Upstream timeout | The provider did not respond in time | Retry once, then fall back |
A provider being unavailable is not the same as a datapoint being absent. Hive distinguishes
the two so your agent does not report "no data" when the truth is "could not check".
## Handling errors in an agent
Give your agent one rule: when a call fails, read the message and act on it rather than
retrying the same call. Hive's errors say which of the above happened, and the right response
differs completely between a rate limit and an invalid argument.
## Error codes
Every code Hive emits, on any transport, with the anchor its `doc_url` points at. Generated from `src/utils/errorCodes.ts`; do not edit by hand.
### ALERT\_NOT\_FOUND
No alert with that id belongs to this account. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** List alerts with `hive_list_alerts` and use an id from that account.
### ANON\_AUTH\_REQUIRED
This tool is not on the keyless lane; add a key or sign in. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Sign in or add an API key; every read-only tool still works keyless.
### ANON\_GLOBAL\_CAP\_EXCEEDED
Hive's shared keyless allowance for today is spent; a key is not subject to it. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Add an API key; the shared keyless pool does not apply to keyed callers.
### ANON\_QUOTA\_EXCEEDED
The keyless daily allowance for this IP is spent; resets 00:00 UTC. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Wait for the 00:00 UTC reset, or add an API key to leave the keyless lane.
### ANON\_QUOTA\_UNAVAILABLE
The keyless limiter is unreachable; retry in a few seconds or use a key. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Retry in a few seconds, or add an API key to skip the keyless limiter.
### API\_ERROR
The server answered with an error the CLI does not map further. Transports: cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Read the message; it is the server's own wording. Retry only if it says the failure is transient.
### AUTH\_NOT\_CONFIGURED
This server has no auth backend configured; keyless discovery still works. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Use the hosted endpoint, or set the auth backend env vars on this server.
### AUTH\_REQUIRED
The call needs an API key or an OAuth session. Transports: rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Send an API key as `Authorization: Bearer `, or sign in. Read-only tools work without one.
### AUTH\_SERVICE\_UNAVAILABLE
The key service is unreachable; retry shortly. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Retry in a few seconds; the key was not rejected.
### CATALOG\_PAGINATION\_ERROR
The tools catalog cursor is invalid; restart from the first page. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Restart from the first page; paginate with `?limit=250&cursor=`.
### ENDPOINT\_NOT\_FOUND
No REST route at that path. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Check the path against `GET /api/openapi.json`.
### FEEDBACK\_RATE\_LIMITED
Feedback is limited to 10 messages per principal per UTC day. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Stop sending feedback until the reset time in the message.
### GENERAL\_ERROR
The CLI hit an unclassified error. Transports: cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Rerun with `--verbose` to see what the CLI hit.
### IDEMPOTENCY\_KEY\_REUSED
That idempotency\_key was already used with different arguments. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Use a new key, or resend the original arguments unchanged.
### INTERNAL\_ERROR
Hive failed unexpectedly; the request id identifies the log line. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Retry once. If it repeats, send the request id from the receipt with `report_feedback`.
### INVALID\_API\_KEY
The API key was rejected; check it in the dashboard. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Copy the key again from the dashboard; keys start with `hive_live_`.
### INVALID\_ARGS
The CLI arguments are invalid. Transports: cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Check `hive --help`; `hive tools info ` prints the parameter table.
### INVALID\_IDEMPOTENCY\_KEY
idempotency\_key must be 1 to 128 characters of letters, digits, \_ - : . Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Send 1 to 128 characters of letters, digits, or \_ - : . as the key.
### INVALID\_OAUTH\_TOKEN
The OAuth token was rejected; sign in again. Transports: mcp. Not retryable: change the request (or the credential) before calling again.
**Do next:** Sign in again in the client; the token expired or was revoked.
### INVALID\_REQUEST
The request body is malformed. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Send a JSON object body with `content-type: application/json`.
### MEMORY\_FACT\_NOT\_FOUND
No memory fact with that id belongs to this account. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** List facts with `hive_list_memory_facts` and use an id from that account.
### MISSING\_PARAM
A required argument is missing. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Add the argument named in the message; `get_api_endpoint_schema` lists the required set.
### MONITOR\_CREDIT\_EXHAUSTED
Scheduled monitors paused: the account's credits are exhausted. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Top up in the dashboard; paused monitors resume on the next cycle.
### MONITOR\_CREDIT\_UNAVAILABLE
The monitor billing check is unavailable; runs retry next cycle. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Nothing to do; the next scheduled run retries the billing check.
### MONITOR\_NOT\_FOUND
No monitor with that id belongs to this account. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** List monitors with `hive_list_monitors` and use an id from that account.
### NO\_WALLET
The account has no credit wallet; initialize billing in the dashboard. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Open the dashboard billing page once to initialize the credit wallet.
### PAYLOAD\_TOO\_LARGE
The request body exceeds the size limit. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Split the request, or bound it with `limit` instead of sending the whole payload.
### PROVIDER\_UNAVAILABLE
The provider is not configured or is down; the receipt says which. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Try the route's fallback tool once, then report the gap with `report_feedback`.
### QUOTA\_EXCEEDED
The account's credit wallet is exhausted for the period. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Top up or upgrade in the dashboard; the balance resets at the start of the next period.
### QUOTA\_SERVICE\_UNAVAILABLE
The billing service could not debit; retry shortly. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Retry in a few seconds. Nothing was debited.
### RATE\_LIMITED
Too many requests per minute; back off and retry. Transports: mcp, rest, cli. Retryable: the same request can succeed later without a change.
**Do next:** Wait the seconds in `retry_after`, then send the request once more.
### SECRET\_ALREADY\_ISSUED
The signing secret was already issued for this subject; rotate it instead. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Rotate the existing secret instead of issuing a second one.
### SHUTTING\_DOWN
The server is draining; retry against the next revision. Transports: rest. Retryable: the same request can succeed later without a change.
**Do next:** Retry; the next revision is already serving.
### STATE\_BACKEND\_UNAVAILABLE
Hive's state store is unreachable; retry shortly. Transports: mcp, rest. Retryable: the same request can succeed later without a change.
**Do next:** Retry in a few seconds; no state was changed.
### STATE\_SUBJECT\_ARCHIVE\_FORBIDDEN
This credential may not archive that subject. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Use the credential that owns the subject.
### STATE\_SUBJECT\_ARCHIVED
The subject this call is scoped to was archived. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Use a live subject; archived subjects are readable but not writable.
### STATE\_SUBJECT\_NOT\_FOUND
The subject this call is scoped to does not exist. Transports: mcp, rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Create the subject first, or call with a subject id this credential owns.
### TIMEOUT
The request exceeded the CLI timeout. Transports: cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Raise `--timeout`, or bound the call with `limit` so there is less to fetch.
### TOOL\_ERROR
The provider returned an error the receipt classifies; read runtime\_status. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Read `runtime_status` in the receipt; retry only when it says `rate_limited` or `degraded`.
### TOOL\_NOT\_FOUND
No tool with that name; search\_tools finds the right one. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Call `search_tools` with the intent, then use the exact name it returns.
### TOOL\_REQUIRED
The request body is missing the tool field. Transports: rest. Not retryable: change the request (or the credential) before calling again.
**Do next:** Put the tool name in the `tool` field of the request body.
### TOOL\_RETIRED
The tool was retired; the message names the replacement call. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Call the replacement named in the message; the old name will not come back.
### UNAUTHORIZED
The credential was rejected: revoked, expired, or malformed. Transports: rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Check the key in the dashboard, then send the current one; rotate it if it was revoked.
### VALIDATION\_ERROR
Arguments failed validation; the message names the field and accepted values. Transports: mcp, rest, cli. Not retryable: change the request (or the credential) before calling again.
**Do next:** Fix the field named in the message; `get_api_endpoint_schema` gives its type and accepted values.
### VERIFICATION\_FAILED
The task result failed validate\_task\_result; the message names the failing check. Transports: mcp. Not retryable: change the request (or the credential) before calling again.
**Do next:** Fix the check named in the message, then call `validate_task_result` again.
# FAQ
Source: https://docs.hiveintelligence.xyz/reference/faq
Common questions about connecting to and building on Hive.
No. The anonymous lane covers 25 material calls per IP per day, resetting at 00:00 UTC.
Add the endpoint and start asking. Discovery calls do not count against it.
Eleven have their own guide: Claude Code, Claude Desktop, Cursor, Windsurf, VS Code,
ChatGPT, Grok, Codex CLI, Kimi Code CLI, Qwen Code, and Gemini CLI. Any client that speaks
MCP over Streamable HTTP works, whether or not it is listed. See [install](/install).
15 providers including CoinGecko, Alchemy, DeFiLlama, GoPlus, CCXT, Helius, Polymarket, and
Hyperliquid. Every response names which one answered. See
[data sources](/concepts/data-sources).
Never. Hive holds the upstream credentials and manages their rate limits for every source
that needs one, and the RWA Perps venues need no credential at all: Hive reads their
official public endpoints keylessly. If a source needs a credential Hive does not hold, the
call returns `missing_key` so you can tell it apart from an outage.
That is intended. The root endpoint stays compact and routes to the rest through
discovery, because a 525 tool list would crowd out the conversation and make selection
worse. See [how it works](/concepts/how-it-works).
Requests stop with a quota error. Hive does not bill overage, so a runaway agent produces
errors rather than an invoice.
No. Hive is read-only market data. It does not execute trades, hold funds, or give
financial advice.
Not with OAuth, which is how most supported clients connect. You add only the URL and the
client stores its own credential. Qwen Code is the exception today: its OAuth configuration
expects a static client id that Hive does not issue, so it reads a bearer token from its
config. Keys are otherwise for headless environments that cannot open a browser.
No. The full secret is shown once at creation; Hive stores only a hash and a short
non-secret prefix. Disable the old key and create a new one.
Sources disagreed beyond a threshold. Rather than silently picking one, Hive sets
`is_price_suspect` so your agent can surface the disagreement.
Every material response carries `fetched_at`. Compare it against your own clock. Provider
health for that call is in `runtime_status`.
News yes, sentiment no. `get_news` returns CoinGecko's article feed, filterable by coin,
and `get_coin_insights` returns its research notes on an Enterprise plan. There are no
social sentiment scores or trend summaries: your model searches the open web better than
an API wrapper would. The rest of Hive is what a model cannot get otherwise, which is live
market state, on-chain data, and contract risk.
# Known limitations
Source: https://docs.hiveintelligence.xyz/reference/known-limitations
What Hive does not do, and where coverage is thinner than you might expect.
Worth knowing before you build on it.
## Official endpoints only
Every provider is accessed through its documented public API. Hive does not scrape sites or
use reverse-engineered private endpoints.
That makes coverage narrower in places than competitors who do scrape, and considerably more
stable. A scraped source breaks without warning when the site changes; a documented API
deprecates on a schedule.
## Little LLM-searchable data
Hive does not serve social sentiment, trend scores, or web summaries. Your model already
searches the web better than an API wrapper would, and putting a stale caching layer between
your agent and an open web source makes the answer worse.
News is the exception: `get_news` returns CoinGecko's article feed with title, description,
URL, author and publication date, filterable by coin, and `get_coin_insights` returns
CoinGecko's research notes on an Enterprise plan. Both are ordinary credentialed tools that
cost a credit like any other.
What Hive is for is what a model cannot get any other way: live market state, on-chain data,
and contract risk.
## Raw datapoints, not opinions
There are no buy signals, price predictions, or risk verdicts. Hive returns the inputs and
your agent forms the judgment. Where a datapoint is questionable, that shows up as a field
like `is_price_suspect` rather than the row being filtered out.
## Coverage varies by chain
EVM chains and Solana have the deepest coverage. Other chains vary by provider and by data
type. A tool existing does not guarantee it covers your chain; ask, or check the category page.
## Portfolio values are estimates
A portfolio total is assembled from per-asset prices fetched at slightly different moments.
Thin tokens may be marked at prices you could not actually realize. Treat totals as
indicative.
## Anonymous lane is for evaluation
25 material calls per IP per day is enough to judge whether Hive fits. It is not a production
tier, and it is capped per IP, so shared networks share the allowance.
## Some provider endpoints are Pro-gated upstream
DeFiLlama's perpetual and derivatives endpoints need a DeFiLlama Pro subscription, and so do its
Pro yield extensions. Those calls return `plan_required` or `missing_key` rather than data. For
perpetual funding, use the CCXT tools instead, and check exact arguments with
`get_api_endpoint_schema` first.
## Docs counts can lag deployment
Tool counts in these docs describe the current release. The deployed catalog is the
authority, and [live catalog](/tools/live-catalog) shows what is actually there.
# Rate limits
Source: https://docs.hiveintelligence.xyz/reference/rate-limits
Per minute limits by plan, and how they interact with credits.
Two separate ceilings apply: how fast you can call, and how much you can call in a month.
## Per minute
| Plan | Rate limit |
| ---------- | ---------------- |
| Free | 100 requests/min |
| Starter | 300 requests/min |
| Pro | 500 requests/min |
| Enterprise | Custom |
Exceeding it returns a rate limit error with headers telling you when to retry. Back off
rather than retrying immediately, or you will simply consume the next window too.
These rates apply once you are authenticated, by key or by OAuth. The keyless anonymous lane
runs on its own lower per-IP ceiling of 30 requests per minute, on top of its 25 material calls
per IP per day, so add a key before you measure throughput.
## Per month
Credits are separate and tracked on your account rather than per key:
| Plan | Monthly credits |
| ---------- | --------------- |
| Free | 10,000 |
| Starter | 100,000 |
| Pro | 500,000 |
| Enterprise | Custom |
Creating more keys does not create more allowance. The per-minute limit is per account too:
every key on the account and every connected OAuth client draw from one shared bucket.
## When you hit either
Hive stops. There is no overage billing, so an agent stuck in a loop produces errors rather
than an invoice. Requests fail with a quota error naming the cause.
Both errors return a `Retry-After` header on the MCP endpoint. The per-minute limit returns the
seconds left in the current window. The monthly credit error returns 60 and, when your billing
cycle end is known, also names that exact instant in its message and `next_action`, so back off
to the named reset rather than retrying every minute. On the REST API the credit error carries
`X-Quota-Remaining` instead, with no `Retry-After` and no reset time.
Current balance and cycle end are on
[dashboard usage](https://www.hiveintelligence.xyz/dashboard/usage).
## Staying inside them
* Use `limit` and `page` instead of pulling result sets you will not read.
* Cache within a task rather than re-fetching the same value per step.
* Connect to a [category endpoint](/tools) when an agent only works in one domain, so
discovery stays cheap.
* Poll on the interval your strategy needs, not the fastest one available.
# Response format
Source: https://docs.hiveintelligence.xyz/reference/response-format
Where Hive attaches provenance across the three surfaces that return it.
Responses are typed and bounded, and material ones carry provenance. Where that provenance
sits depends on which surface answered.
## MCP tools
Tools reached through discovery attach a top-level `_hive` object alongside the payload:
```json theme={null}
{
"_hive": {
"receipt_id": "9f2c…",
"provider": "CoinGecko",
"tool": "get_price",
"runtime_status": "ok",
"fetched_at": "2026-08-19T14:22:07Z",
"cache_status": "miss",
"duration_ms": 184,
"credit_cost": 1,
"credits_used": 1,
"credits_remaining": 9774
}
}
```
`_hive` also carries `receipt_version` (always `"1.0"`; the credit fields were added without
bumping it), `server_version`, `input_digest`, and `result_digest`. `credit_cost`,
`credits_used` and `credits_remaining` are described under
[receipts](/concepts/receipts#what-the-call-cost); on an error the object also carries
`cause`, `next_action` and `doc_url`. The digests are SHA-256 self-checks over the canonical arguments and the
normalized payload. They let you detect accidental mutation; they are not server signatures.
## Hero tools
The three hero tools add a `source_receipt` describing the provider call they made underneath,
alongside their own top-level `_hive`:
```json theme={null}
{
"source_receipt": {
"provider": "CoinGecko",
"tool": "get_price",
"runtime_status": "ok",
"fetched_at": "2026-08-19T14:22:07Z",
"cache_status": "hit",
"source": "cached",
"receipt_id": "9f2c…"
}
}
```
A hero response carries both objects, so do not treat a missing `_hive` as the way to detect
one. `source` is an enum with four values: `live`, `cached`, `fallback`, and `unavailable`.
Same three fields you care about, different container. See [receipts](/concepts/receipts).
## CLI
`hive ... --json` is a third shape. It wraps everything in an envelope, and the provenance
lands in `meta` rather than `_hive` or `source_receipt`:
```json theme={null}
{
"ok": true,
"data": {},
"meta": {
"tool": "get_token_price",
"provider": "Hive",
"runtime_status": "ok",
"source": "live",
"truncated": false,
"credit_cost": 1,
"credits_used": 1,
"credits_remaining": 9775,
"quota_remaining": 9775
}
}
```
`quota_remaining` is a deprecated alias of `credits_remaining` kept for one release; read
the new name. `meta.tool` is the tool you called and `meta.provider` is the surface that served it, so a hero
tool reads `Hive` here. The upstream provider for that call is in `source_receipt` inside
`data`, not in `meta`.
`--jq` filters `data` only, so `--jq '.price'` reaches into the payload and not the envelope.
`--jq '.ok'` returns nothing, because `ok` lives on the envelope.
## runtime\_status values
`runtime_status` is an enum, not free text:
| Value | Meaning |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `ok` | The call succeeded against a healthy provider |
| `invalid_input` | Your arguments failed validation, or the venue and method combination is unsupported. Fixable by correcting the call |
| `missing_key` | The provider is not configured |
| `plan_required` | The upstream provider's own plan, quota, or credits block the call, not your Hive plan |
| `rate_limited` | Throttled |
| `degraded` | The tool exists, but the provider is temporarily unavailable or unstable. Retry after a pause, and treat any partial result as low confidence |
| `failing` | The call returned an unexpected error, upstream or inside Hive. Read `cause` and `next_action` before deciding what to do |
`invalid_input` is worth handling separately: it is not an outage, so retrying unchanged will
fail the same way.
## Cache fields
`cache_status` tells you whether the response came from Hive's cache. On a hit, `observed_at`
is when Hive first saw the data and `cache_age_ms` is how long ago that was.
A `cache_age_ms` of zero means Hive fetched from the provider just now. It does not promise
that the provider's own underlying datum is current.
## Normalization fields
Where Hive knows something is off about a datapoint, it says so in a field rather than
dropping the row:
| Field | Meaning |
| ------------------- | ------------------------------------------------------ |
| `is_delisted` | No longer actively traded on the venue |
| `is_price_suspect` | Diverges enough from other sources to warrant a check |
| `funding_mechanism` | How this venue calculates funding, since venues differ |
Your agent decides what to do with a flagged row. Hive does not filter it out for you.
## Bounded output
Where a list-returning tool supports `limit`, `page`, `per_page`, or `offset`, use them. Not
every tool takes all four, so check the schema with `get_api_endpoint_schema` or
`hive tools info `.
Hive caps total response size regardless of what you ask for: 25,000 tokens, or roughly 100,000
characters. Responses trimmed to fit set `truncated` to `true`. An unbounded response would burn
the context your agent needs for the actual task.
## Errors
Failures return the same four legs on every surface: `code`, `message`, `cause`,
`next_action`, plus `retryable`, `retry_after` when a wait is known, and `doc_url`, an anchor
on the [errors page](/reference/errors). REST keeps `type`, `param` and `request_id`
alongside; JSON-RPC cap errors carry the fields under `error.data`; the CLI keeps
`suggestion` as an alias of `next_action` for one release.
# Agent skills
Source: https://docs.hiveintelligence.xyz/skills/index
Installable workflow packs that teach an agent to run a whole investigation, start to finish.
A tool call answers one question. A skill teaches your agent how to run an investigation:
which tools to reach for, in what order, what to check along the way, and how to report the
result with its sources attached.
Hive publishes 18 skill packs, starting with the `hive` umbrella pack that routes to the rest.
They install through the `skills` CLI and are
packaged with a Claude plugin manifest.
## Install
Everything at once:
```bash theme={null}
npx skills add hive-intel/hive-skills
```
Or a single pack:
```bash theme={null}
npx skills add hive-intel/hive-skills --skill hive-token-diligence --yes
```
See what is available before installing:
```bash theme={null}
npx skills add hive-intel/hive-skills --list
```
The packs live at
[github.com/hive-intel/hive-skills](https://github.com/hive-intel/hive-skills).
## What a skill changes
Without a skill, asking an agent to vet a token gets you whatever it thinks to check. With
`hive-token-diligence` installed, it follows a route: resolve the canonical asset first, pull
market context and liquidity, check holder concentration, run contract risk, then give a
verdict with a receipt behind each claim.
The difference shows up most on questions where the naive answer is confidently wrong. An
agent that checks one price source will tell you a delisted token is worth something. An
agent following the diligence route sees `is_delisted` and says so.
## Skills and MCP together
Skills do not replace the MCP connection. They sit on top of it: the skill decides what to
call, and Hive's endpoint serves the call. Install both.
All 17, grouped by what they do.
# Skill packs
Source: https://docs.hiveintelligence.xyz/skills/packs
All 18 Hive agent skill packs, grouped by purpose.
Install any of these with:
```bash theme={null}
npx skills add hive-intel/hive-skills --skill --yes
```
## Start here
| Pack | What it does |
| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hive` | The umbrella pack. Detects whether to use MCP or the `hive` CLI, carries the one setup command, the opt-in routing block, the eight-tool loop, the credit and error tables, and the feedback triggers. It loads the packs below when a question needs them |
## Setup and integration
| Pack | What it does |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `hive-mcp` | Connect Hive's MCP endpoint to any supported client, including OAuth sign-in, headless key fallback, and debugging missing tools or 401s |
| `hive-build-onboarding` | Walk through browser auth, dashboard key creation, and headless environment setup |
| `hive-build` | Use Hive from application code, through MCP clients or the published TypeScript adapter |
| `hive-cli` | Run Hive from shell scripts, cron jobs, and terminal research |
## Routing and discovery
| Pack | What it does |
| -------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `hive-query` | Start from the user's intent, pick the right task toolset, inspect schemas, and call exactly what is needed |
| `hive-tool-discovery` | Task discovery, schema lookup, read-only invocation, and result verification |
| `hive-stateful-monitoring` | Create, list, update, and archive durable monitors that agents can schedule against |
## Research workflows
| Pack | What it does |
| ----------------------------- | ------------------------------------------------------------------------------------------------ |
| `hive-market-research` | Prices, liquidity, exchanges, OHLC, order books, and derivatives context |
| `hive-token-diligence` | Token metadata, market context, liquidity, holders, enrichment, and risk |
| `hive-wallet-investigation` | Wallet balances, transfers, NFTs, PnL, DeFi positions, and notable activity |
| `hive-security-risk` | Token, approval, address, phishing, contract, and simulation risk signals |
| `hive-dex-pool-analysis` | On-chain pools, pairs, liquidity, trades, OHLCV, and DEX flow |
| `hive-defi-research` | Protocols, TVL, fees, revenue, stablecoins, bridges, and yield pools |
| `hive-nft-research` | Collections, ownership, metadata, floor price, sales, rarity, and spam checks |
| `hive-solana-analysis` | Solana wallets, SPL token accounts, DAS assets, parsed transactions, and priority fees |
| `hive-network-infrastructure` | Chain state, gas, blocks, receipts, logs, transaction status, and RPC diagnostics |
| `hive-prediction-markets` | Polymarket events, markets, market-implied odds, order books, odds history, and wallet positions |
## Picking one
If you are unsure, install `hive`. It is the umbrella pack: it handles setup, picks the
transport, and loads `hive-query` when a question needs the full toolset walk.
Install a specialised pack when your agent does the same kind of investigation repeatedly and
you want the full route every time. `hive-token-diligence` and `hive-wallet-investigation` are
the two that earn their place fastest.
# DeFi Protocol Analytics
Source: https://docs.hiveintelligence.xyz/tools/defi
TVL, yields, fees, chain breakdowns, stablecoins, tracked hacks. 26 tools on a dedicated Hive endpoint.
TVL, yields, fees, chain breakdowns, stablecoins.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_defi_protocol/mcp
```
26 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# On-Chain DEX & Pool Analytics
Source: https://docs.hiveintelligence.xyz/tools/dex-analytics
Pool, pair, liquidity, and trade flow data across major EVM and Solana markets. 46 tools on a dedicated Hive endpoint.
Pool, pair, liquidity, and trade flow data across major EVM and Solana markets.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_onchain_dex/mcp
```
46 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Tools
Source: https://docs.hiveintelligence.xyz/tools/index
Ten categories covering 525 callable tools, and how your agent finds the right one.
Hive exposes 527 provider tools across ten categories, plus 19 Hive-native tools for durable
monitoring, memory, alerts, reports, and feedback. That is 525 callable tools in total.
You will not wire any of them up by hand.
## How your agent finds a tool
The root endpoint shows eight tools, not 525. Your agent narrows from there:
```
search_tools("check if this token is a honeypot")
-> get_api_endpoint_schema(tool_name)
-> invoke_api_endpoint(tool_name, args)
```
[How Hive works](/concepts/how-it-works) covers why the root list stays small.
## The categories
| Category | Tools | Covers |
| ----------------------------------------------------- | ----- | ---------------------------------------------------------------------------------------------------- |
| [Market Data & Price](/tools/market-data) | 150 | Spot, OHLC, market caps, volume, derivatives, exchanges |
| [On-Chain DEX & Pool Analytics](/tools/dex-analytics) | 46 | Pool, pair, liquidity, and trade flow data across major EVM and Solana markets |
| [Portfolio & Wallet](/tools/portfolio) | 96 | Wallet balances, history, PnL, approvals across EVM and Solana |
| [Token & Contract Data](/tools/token-contract) | 40 | Token metadata, holders, top traders, analytics |
| [DeFi Protocol Analytics](/tools/defi) | 26 | TVL, yields, fees, chain breakdowns, stablecoins |
| [NFT Analytics](/tools/nft) | 59 | Collections, floors, sales, holders, traits, compressed NFTs |
| [Security & Risk Analysis](/tools/security) | 51 | Token, NFT, dApp, wallet scans; honeypot, rug-pull, simulation, LP locks |
| [Network & Infrastructure](/tools/network) | 33 | Network lists, gas, block numbers, exchange status, and Solana infrastructure |
| [Search & Discovery](/tools/search) | 19 | Cross-provider search across coins, tokens, exchanges, categories, events |
| [Prediction Markets](/tools/prediction-markets) | 7 | Polymarket market and event search, market-implied odds, order books, odds history, wallet positions |
## Narrowing to one category
Each category has its own endpoint. Connect to it directly and your agent sees only that
category's tools, with no discovery step:
```
https://mcp.hiveintelligence.xyz/hive_market_data/mcp
```
This is worth doing when an agent only ever works in one domain. A wallet-analysis agent does
not need NFT tools competing for its attention.
## The live catalog is the authority
Tool counts here describe the current release. What is actually deployed can differ, and the
live catalog always wins.
Check what is deployed right now.
# Live catalog
Source: https://docs.hiveintelligence.xyz/tools/live-catalog
Check which tools are deployed right now, rather than trusting a number in the docs.
Documentation goes stale. The deployed catalog does not.
## From your agent
Ask it to list what it can reach:
> List the Hive tool categories available to you, and how many tools are in each.
Your agent reads this from the live server, so the answer reflects what is actually deployed
rather than what was true when these docs were written.
## From the CLI
```bash theme={null}
hive tools list
```
Narrow it to a task:
```bash theme={null}
hive tools search "funding rates"
```
Then inspect one before calling it:
```bash theme={null}
hive tools info get_funding_rates
```
## Why counts here can differ
The numbers in [tools](/tools) describe the current release. A provider outage, a paused
integration, or a deploy in progress can all mean a tool is temporarily unavailable even
though it is documented.
That is what `runtime_status` on every response is for. A provider that is degraded says so
in the receipt rather than returning a confident wrong answer. See
[receipts](/concepts/receipts).
## Checking service health
[The status page](https://www.hiveintelligence.xyz/status) reports transport
reachability, OAuth lifecycle, provider probes, task canaries, workflow routing, MCP protocol
behavior, and catalog integrity as separate signals, each with its own evidence and
observation time.
# Market Data & Price
Source: https://docs.hiveintelligence.xyz/tools/market-data
Spot, OHLC, market caps, volume, derivatives, exchanges, sentiment and technical indicators. 150 tools on a dedicated Hive endpoint.
Spot, OHLC, market caps, volume, derivatives, exchanges.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_market_data/mcp
```
150 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Network & Infrastructure
Source: https://docs.hiveintelligence.xyz/tools/network
Network lists, gas, block numbers, exchange status, and Solana infrastructure. 33 tools on a dedicated Hive endpoint.
Network lists, gas, block numbers, exchange status, and Solana infrastructure.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_network_infrastructure/mcp
```
33 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# NFT Analytics
Source: https://docs.hiveintelligence.xyz/tools/nft
Collections, floors, sales, holders, traits, compressed NFTs. 59 tools on a dedicated Hive endpoint.
Collections, floors, sales, holders, traits, compressed NFTs.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_nft_analytics/mcp
```
59 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Portfolio & Wallet
Source: https://docs.hiveintelligence.xyz/tools/portfolio
Wallet balances, history, PnL, approvals across EVM and Solana. 96 tools on a dedicated Hive endpoint.
Wallet balances, history, PnL, approvals across EVM and Solana.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_portfolio_wallet/mcp
```
96 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Prediction Markets
Source: https://docs.hiveintelligence.xyz/tools/prediction-markets
Polymarket market and event search, market-implied odds, order books, odds history, wallet positions. 7 tools on a dedicated Hive endpoint.
Market-implied odds from Polymarket: find markets and events, read the live order book and the
odds history behind a price, and inspect what a trader holds and trades.
A prediction-market price is what the market will pay for an outcome, not the probability
that the outcome is true. Quote it as implied odds, with the liquidity and spread behind it.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_prediction_markets/mcp
```
7 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## What is covered
Polymarket's Gamma, CLOB, and Data APIs are public, so these tools work on the keyless lane
with no account.
| Tool | Answers |
| --------------------------------- | ----------------------------------------------------------------------------- |
| `polymarket_search_markets` | Which markets exist for a topic, with their slugs and outcome token ids |
| `polymarket_get_events` | The candidate markets inside one event, such as an election |
| `polymarket_get_market` | One market by slug or condition id, with its last implied price and liquidity |
| `polymarket_get_orderbook` | The live book for one outcome token, with spread and depth |
| `polymarket_get_price_history` | Bounded odds history for one outcome token over a window |
| `polymarket_get_wallet_positions` | What one wallet holds across markets |
| `polymarket_get_wallet_activity` | What one wallet recently bought and sold |
Hyperliquid's HIP-4 onchain outcome markets stay in
[Market Data & Price](/tools/market-data) as `hyperliquid_get_outcome_meta` and
`hyperliquid_get_settled_outcome`.
Kalshi is not covered. Its developer agreement requires prior written authorization before
its API data is shared with anyone else, and Hive does not hold that authorization.
## Finding a specific tool
Rather than listing every argument here, ask Hive:
```
search_tools("odds on the next fed decision")
```
The [`prediction_markets` task toolset](/concepts/workflows) carries the three routes an agent
should follow: an odds snapshot, an odds trend, and a trader's flow.
## From the CLI
```bash theme={null}
hive tools search polymarket
hive tools info polymarket_get_orderbook
hive tools call polymarket_search_markets --query "fed rate" --limit 5
```
# Search & Discovery
Source: https://docs.hiveintelligence.xyz/tools/search
Cross-provider search across coins, tokens, exchanges, categories, events. 19 tools on a dedicated Hive endpoint.
Cross-provider search across coins, tokens, exchanges, categories, events.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_search_discovery/mcp
```
19 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Security & Risk Analysis
Source: https://docs.hiveintelligence.xyz/tools/security
Token, NFT, dApp, wallet scans; honeypot, rug-pull, simulation, LP locks. 51 tools on a dedicated Hive endpoint.
Token, NFT, dApp, wallet scans; honeypot, rug-pull, simulation, LP locks.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_security_risk/mcp
```
51 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.
# Token & Contract Data
Source: https://docs.hiveintelligence.xyz/tools/token-contract
Token metadata, holders, top traders, analytics. 40 tools on a dedicated Hive endpoint.
Token metadata, holders, top traders, analytics.
## Endpoint
Connect here to expose only this category to your agent:
```
https://mcp.hiveintelligence.xyz/hive_token_contract/mcp
```
40 tools live behind it. The root endpoint reaches the same tools through
[discovery](/concepts/how-it-works), so use this narrower endpoint when an agent works only
in this domain.
## Finding a specific tool
Rather than listing every tool here, ask Hive:
```
search_tools("")
```
The catalog changes as providers add coverage, so discovery gives you the current answer
where a static list would go stale. [The live catalog](/tools/live-catalog) shows exactly what
is deployed.
## From the CLI
```bash theme={null}
hive tools search ""
hive tools info
```
The CLI matches literal text against tool names and descriptions, so search for a keyword
like `funding` or `holders`. `search_tools` above understands intent; `hive tools search`
does not, and a full phrase returns nothing.