# Kava Explorer MCP

> Kava Explorer lets you inspect the Kava blockchain using your AI client. It pulls detailed data on account balances, transaction history, block metrics, and validator performance directly from Subscan. You can audit addresses for rewards or slashes, track specific asset movements (extrinsics), or monitor network health without leaving your IDE. This is deep, verifiable chain state analysis.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** kava, blockchain-explorer, crypto-data, staking, transactions

## Description

You need to know exactly what happened on the Kava blockchain. This MCP connects your AI agent to Subscan, giving it visibility into everything from simple token balances to complex validator metrics. It handles all the heavy lifting of reading raw on-chain data so you don't have to write custom query scripts every time.

Whether you are auditing an address for historical rewards or tracing a specific asset transfer across blocks, your AI client can call these tools and return clean, structured data. This is critical for research, compliance checks, or debugging complex dApp behavior. By connecting through Vinkius, this MCP becomes available to any compatible agent, making deep blockchain analysis accessible right where you're working—your terminal or code editor. You get full visibility into the network state using plain conversation.

## Tools

### get_account_info
Retrieves basic details about a specific Kava account address.

### get_account_reward_slash
Checks the reward and slash records for an entire account.

### get_account_token
Gets the specific token balances held by a given address.

### get_block
Fetches all details for a block using its hash or height number.

### list_blocks
Provides a list of recent block hashes and heights.

### list_events
Lists system events from the chain, allowing filtering by criteria.

### get_extrinsic
Gets the full details of an asset transfer by its unique identifier (hash or index).

### list_extrinsics
Gets a list of recent asset transfers across the network.

### get_validator
Retrieves detailed performance and status information for one validator node.

### list_validators
Provides a complete roster and status list of all validators.

## Prompt Examples

**Prompt:** 
```
Show me the balance and account info for Kava address kava1...
```

**Response:** 
```
I've retrieved the account info for kava1... The account currently holds 1,250 KAVA with a nonce of 42. Would you like to see the specific token balances as well?
```

**Prompt:** 
```
What are the latest blocks on the Kava network?
```

**Response:** 
```
Fetching the most recent blocks... The latest block is #5,402,120, produced 6 seconds ago by validator 'KavaLabs'. There were 12 extrinsics in this block.
```

**Prompt:** 
```
Check the rewards and slashes for address kava1...
```

**Response:** 
```
I found 15 reward events for this address in the last 24 hours, totaling 5.2 KAVA. No slash events were detected in the recent history.
```

## Capabilities

### Audit account history
Retrieve an address’s token balances and check its specific reward or slash events.

### Track transaction movements
Query asset transfers (extrinsics) by hash, list recent transactions with filters, or review all recorded block data.

### Monitor network health
Fetch real-time block details and list system events emitted across the entire Kava mainnet.

### Analyze staking status
Access a full list of validators and drill down into any specific validator’s performance metrics.

## Use Cases

### Investigating a failed transfer
A developer notices a transaction stalled. They use the MCP to first run `list_extrinsics` to find the hash, then call `get_extrinsic` to see exactly where and why the asset movement stopped.

### Auditing corporate wallet health
An analyst needs quarterly proof of funds. They use the MCP to run `list_validators` for system context, then repeatedly call `get_account_token` across multiple addresses to compile a full asset report.

### Debugging node connectivity
A node operator suspects network issues. They query the MCP using `list_blocks` and then check specific event streams via `list_events` to confirm if nodes are emitting expected system data.

## Benefits

- Audit accounts for history: Use `get_account_reward_slash` to immediately see if an address received rewards or incurred slashes without manual dashboard navigation.
- Verify asset movement: Instead of guessing, use `list_extrinsics` and then `get_extrinsic` to pull the exact details on any transfer hash you find.
- Check network status instantly: The MCP lets you call `list_blocks` or `list_events` to get real-time data on block height and system activity for immediate debugging.
- Deep validator analysis: Pull full metrics using `get_validator` and `list_validators`. This is crucial for understanding staking health and network reliability.
- Complete financial picture: Combine calls like `get_account_token` with `get_account_info` to build a single, verifiable picture of an address's current holdings and state.

## How It Works

The bottom line is you ask a natural language question, and this MCP sends the request to Subscan to get verifiable on-chain answers.

1. Subscribe to this MCP on Vinkius and input your Subscan API Key.
2. Instruct your AI client to perform the desired query, like 'Show me the token balance for kava1...'
3. The agent executes the necessary tool calls and returns structured data summarizing account info or block details.

## Frequently Asked Questions

**How do I use get_account_info to check an address?**
You give your agent the specific Kava address and ask it to run `get_account_info`. It returns basic account metadata, like its current status and nonce. This is always the starting point for auditing any account.

**What's the difference between list_extrinsics and get_extrinsic?**
`list_extrinsics` gives you a paginated summary of many recent transfers across the network. `get_extrinsic`, however, requires you to provide a specific hash or index so it returns all data for just that single asset movement.

**Can I check token balances using get_account_token?**
Yes. If you need to know how many of one specific type of token an account holds, `get_account_token` provides the precise balance for that asset ID.

**How do I check rewards and slashes using get_account_reward_slash?**
You pass the address to the MCP and ask it to run `get_account_reward_slash`. This single tool call retrieves all recorded reward events and any slash penalties for that account's history.

**When I use list_blocks, what data points does it provide about the network's recent activity?**
It returns key block details like the height, timestamp, and which validator produced the block. This is crucial for tracking when transactions actually settled on the Kava mainnet.

**If I use get_validator, what input do I need to provide to pull a specific validator's profile?**
You must supply the unique validator ID or address. This tool pulls deep metrics, including operational status and staking performance for that single entity.

**Does list_events allow me to filter results by module name or event topic?**
Yes, you pass filtering parameters directly into the query. You can narrow down massive datasets so you only get events related to what you're actively researching.

**If I run get_account_token and a specific token balance is zero, how should I interpret that result?**
It simply means the account currently doesn't hold that particular asset. The tool reports the current state accurately; no further action or investigation is required.

**Can I check the token balances for a specific Kava address?**
Yes! Use the `get_account_token` tool with the target Kava address to retrieve all token balances associated with that account.

**How do I find details about a specific transaction or extrinsic?**
You can use the `get_extrinsic` tool by providing either the transaction hash or the extrinsic index (e.g., '123456-2').

**Is it possible to monitor validator performance and staking status?**
Absolutely. Use `list_validators` to see the network-wide list, and `get_validator` with a specific address to see detailed performance and staking metrics.