diff --git a/docs/HIVE_APIS.md b/docs/HIVE_APIS.md
new file mode 100644
index 00000000..d73d7a8e
--- /dev/null
+++ b/docs/HIVE_APIS.md
@@ -0,0 +1,253 @@
+# Hive API Documentation for D.Buzz
+
+## Overview
+
+D.Buzz uses multiple Hive blockchain API nodes to ensure reliability and availability. The application implements an automatic failover system that switches between nodes when one becomes unavailable.
+
+## Current Hive API Configuration
+
+### Primary RPC Node
+
+The default RPC node is configured in `src/config.js`:
+
+```javascript
+DEFAULT_RPC_NODE: process.env.REACT_APP_DEFAULT_RPC_NODE || 'https://api.hive.blog'
+```
+
+**Default Node:** `https://api.hive.blog` (operated by @blocktrades)
+
+### Backup API Nodes
+
+The following backup nodes are configured in `src/services/helper.js`:
+
+| API Endpoint | Operator | Status |
+|--------------|----------|--------|
+| https://hive-api.3speak.tv | @threespeak | Backup |
+| https://rpc.mahdiyari.info | @mahdiyari | Backup |
+| https://anyx.io | @anyx | Backup |
+| https://api.deathwing.me | @deathwing | Backup |
+| https://hived.emre.sh | @emrebeyler | Backup |
+| https://api.openhive.network | @gtg | Backup |
+| https://techcoderx.com | @techcoderx | Backup |
+| https://api.c0ff33a.uk | @c0ff33a | Backup |
+
+### Additional Known Hive API Nodes
+
+The following public nodes are also available but not currently configured in D.Buzz:
+
+| API Endpoint | Operator |
+|--------------|----------|
+| https://rpc.ausbit.dev | @ausbitbank |
+| https://api.hive.blue | @guiltyparties |
+| https://hive.roelandp.nl | @roelandp |
+| https://hive-api.arcange.eu | @arcange |
+| https://hiveapi.actifit.io | @actifit |
+
+## Automatic Failover System
+
+### Implementation
+
+The failover system is implemented in `src/services/api.js` and provides the following features:
+
+#### 1. Failed API Tracking
+
+```javascript
+const failedAPIs = new Map() // Track failed APIs with timestamps
+const API_COOLDOWN_MS = 5 * 60 * 1000 // 5 minutes cooldown
+```
+
+- APIs that fail are marked with a timestamp
+- Failed APIs enter a 5-minute cooldown period
+- After cooldown, APIs are automatically retried
+
+#### 2. Available API Selection
+
+The `getAvailableAPIs()` function:
+- Filters out recently failed APIs
+- Removes APIs from the failed list after cooldown expires
+- Returns list of currently available nodes
+
+#### 3. Automatic Rotation
+
+The `getNextAvailableAPI()` function:
+- Rotates through available APIs using round-robin
+- Resets to first API if all APIs have failed
+- Clears failed list when all nodes are unavailable
+
+#### 4. API Call Wrapper
+
+The `apiCallWithFailover()` function wraps API calls with automatic retry:
+
+```javascript
+export const apiCallWithFailover = async (apiCallFunction, maxRetries = 3) => {
+  // Attempts up to 3 times by default
+  // Marks failed APIs and switches to next available node
+  // Implements exponential backoff (1s, 2s, 3s)
+}
+```
+
+### Usage Examples
+
+#### Setting RPC Node
+
+```javascript
+import { setRPCNode } from 'services/api'
+
+// Automatically selects next available node with failover
+await setRPCNode()
+```
+
+#### Making API Calls with Failover
+
+```javascript
+import { apiCallWithFailover } from 'services/api'
+
+// Wrap any API call for automatic failover
+const result = await apiCallWithFailover(() => {
+  return api.call('bridge.get_profile', { account: 'username' })
+})
+```
+
+#### Getting Active RPC Node
+
+```javascript
+import { getActiveRPCNode } from 'services/api'
+
+const currentNode = getActiveRPCNode()
+// Returns user-selected node or next available node from rotation
+```
+
+## Hive API Methods Used
+
+D.Buzz uses the following Hive blockchain API methods:
+
+### Bridge API Methods
+
+- `bridge.get_profile` - Fetch user profile information
+- `bridge.get_discussion` - Fetch post and comments
+- `bridge.unread_notifications` - Get unread notification count
+- `bridge.account_notifications` - Get account notifications
+- `bridge.get_community` - Get community information
+- `bridge.get_account_posts` - Fetch posts from an account
+- `bridge.get_relationship_between_accounts` - Check follow relationships
+- `bridge.get_follow_list` - Get user's follow lists
+
+### Condenser API Methods
+
+- `condenser_api.get_trending_tags` - Fetch trending tags
+- `condenser_api.get_dynamic_global_properties` - Get blockchain properties
+- `condenser_api.get_following` - Get accounts a user follows
+- `condenser_api.list_proposal_votes` - Get proposal votes
+
+### Database API Methods
+
+- `getAccounts` - Get account information
+- `getContent` - Fetch post content
+- `getContentReplies` - Fetch replies to a post
+- `getActiveVotes` - Get votes on a post
+- `getDynamicGlobalProperties` - Get global blockchain properties
+- `getFollowCount` - Get follower/following counts
+- `getFollowers` - Get account followers
+- `getFollowing` - Get accounts user follows
+- `getFeedHistory` - Get price feed history
+- `getRewardFund` - Get reward pool information
+- `getAccountHistory` - Get account transaction history
+
+### Broadcast Methods
+
+- `broadcast.vote` - Cast a vote
+- `broadcast.send` - Broadcast transactions (posts, comments, follows, etc.)
+
+## RPC Node Selection
+
+Users can manually select their preferred RPC node through the application settings. The selection is stored in localStorage:
+
+```javascript
+const rpcSetting = localStorage.getItem('rpc-setting')
+```
+
+If a user selects a specific node (not 'default'), that node will be used instead of the automatic rotation system.
+
+## Testing Hive APIs
+
+A test script is available at `/test-hive-apis.js` that can be used to verify the availability of Hive API endpoints:
+
+```bash
+node test-hive-apis.js
+```
+
+The test script:
+- Tests all configured endpoints
+- Measures response times
+- Reports working vs. failed nodes
+- Shows head block numbers for verification
+
+## Troubleshooting
+
+### If API Calls Fail
+
+1. **Check Network Connection**: Ensure you have internet connectivity
+2. **Check Console Logs**: Failed APIs are logged with warnings
+3. **Wait for Cooldown**: Failed APIs automatically retry after 5 minutes
+4. **Try Manual Node Selection**: Select a different RPC node in settings
+5. **Clear Failed APIs**: Restart the application to reset failed API tracking
+
+### Common Error Codes
+
+- `-32000`: General RPC error
+- `-32001`: Post already paid out (voting forbidden)
+- `EAI_AGAIN`: DNS resolution failure (network issue)
+- `ECONNREFUSED`: Connection refused (node offline)
+- `ETIMEDOUT`: Request timeout (node overloaded or slow)
+
+## Adding New Hive API Nodes
+
+To add a new Hive API node to the rotation:
+
+1. Add the URL to `hiveAPIUrls` array in `src/services/helper.js`:
+
+```javascript
+export const hiveAPIUrls = [
+  "https://hive-api.3speak.tv",
+  // ... existing nodes ...
+  "https://your-new-node.com",  // Add new node here
+]
+```
+
+2. The node will automatically be included in the failover rotation
+
+## Security Considerations
+
+- All API nodes use HTTPS for secure communication
+- Private keys are never sent to API nodes
+- Transactions are signed locally before broadcasting
+- User credentials are stored locally (not on API servers)
+
+## Performance Optimization
+
+The failover system includes several optimizations:
+
+1. **Cooldown Period**: Prevents repeated attempts to failed nodes
+2. **Round-robin Rotation**: Distributes load across available nodes
+3. **Exponential Backoff**: Reduces network congestion during retries
+4. **Local Caching**: Profile data is cached to reduce API calls
+
+## API Rate Limits
+
+Different Hive API nodes may have different rate limits. The automatic rotation helps distribute requests across multiple nodes to avoid hitting individual node limits.
+
+## References
+
+- [Hive Developer Documentation](https://developers.hive.io/)
+- [Hive.js Library](https://www.npmjs.com/package/@hiveio/hive-js)
+- [Public Hive API Nodes List](https://beacon.peakd.com/)
+
+## Version History
+
+- **v3.0.0**: Implemented automatic failover system with cooldown
+- **v2.x**: Multiple API node support
+- **v1.x**: Single API node configuration
+
+---
+
+**Last Updated**: 2025-10-26
diff --git a/docs/HIVE_API_QUICK_REFERENCE.md b/docs/HIVE_API_QUICK_REFERENCE.md
new file mode 100644
index 00000000..808f908f
--- /dev/null
+++ b/docs/HIVE_API_QUICK_REFERENCE.md
@@ -0,0 +1,335 @@
+# Hive API Quick Reference
+
+## Currently Configured APIs in D.Buzz
+
+### Production APIs (Configured)
+
+These APIs are currently configured in the D.Buzz client and part of the automatic failover system:
+
+```javascript
+// Primary (default)
+https://api.hive.blog                 // @blocktrades
+
+// Backup nodes (automatic failover)
+https://hive-api.3speak.tv            // @threespeak
+https://rpc.mahdiyari.info            // @mahdiyari
+https://anyx.io                       // @anyx
+https://api.deathwing.me              // @deathwing
+https://hived.emre.sh                 // @emrebeyler
+https://api.openhive.network          // @gtg
+https://techcoderx.com                // @techcoderx
+https://api.c0ff33a.uk                // @c0ff33a
+```
+
+**Total Configured Nodes**: 9 (1 primary + 8 backup)
+
+### Alternative Public APIs (Not Configured)
+
+These public Hive APIs are available but not currently in the D.Buzz configuration:
+
+```javascript
+https://rpc.ausbit.dev                // @ausbitbank
+https://api.hive.blue                 // @guiltyparties
+https://hive.roelandp.nl              // @roelandp
+https://hive-api.arcange.eu           // @arcange
+https://hiveapi.actifit.io            // @actifit
+```
+
+## Testing API Availability
+
+### Method 1: Using the Test Script
+
+```bash
+node test-hive-apis.js
+```
+
+This script will test all endpoints and report:
+- Response times
+- Current head block number
+- Working vs. failed status
+- Error messages for failed nodes
+
+### Method 2: Manual cURL Test
+
+Test a single endpoint manually:
+
+```bash
+# Test basic connectivity
+curl -X POST https://api.hive.blog \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "condenser_api.get_dynamic_global_properties",
+    "params": [],
+    "id": 1
+  }'
+```
+
+Expected response includes:
+- `head_block_number`: Current blockchain height
+- `total_vesting_shares`: Total HIVE Power in network
+- `total_vesting_fund_hive`: Total HIVE backing HP
+
+### Method 3: JavaScript/Node.js
+
+```javascript
+const https = require('https');
+
+const testHiveAPI = (url) => {
+  const payload = JSON.stringify({
+    jsonrpc: '2.0',
+    method: 'condenser_api.get_dynamic_global_properties',
+    params: [],
+    id: 1
+  });
+
+  const urlObj = new URL(url);
+
+  const options = {
+    hostname: urlObj.hostname,
+    port: 443,
+    path: '/',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload)
+    }
+  };
+
+  const req = https.request(options, (res) => {
+    let data = '';
+    res.on('data', (chunk) => { data += chunk; });
+    res.on('end', () => {
+      const result = JSON.parse(data);
+      if (result.result) {
+        console.log(`✓ ${url} - Block: ${result.result.head_block_number}`);
+      }
+    });
+  });
+
+  req.on('error', (e) => {
+    console.error(`✗ ${url} - Error: ${e.message}`);
+  });
+
+  req.write(payload);
+  req.end();
+};
+
+// Test all configured nodes
+const nodes = [
+  'https://api.hive.blog',
+  'https://hive-api.3speak.tv',
+  'https://rpc.mahdiyari.info',
+  'https://anyx.io',
+  'https://api.deathwing.me',
+  'https://hived.emre.sh',
+  'https://api.openhive.network',
+  'https://techcoderx.com',
+  'https://api.c0ff33a.uk'
+];
+
+nodes.forEach(testHiveAPI);
+```
+
+## Common API Methods
+
+### Get User Profile
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "method": "bridge.get_profile",
+  "params": {
+    "account": "username"
+  },
+  "id": 1
+}
+```
+
+### Get Posts
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "method": "bridge.get_account_posts",
+  "params": {
+    "sort": "posts",
+    "account": "username",
+    "limit": 20
+  },
+  "id": 1
+}
+```
+
+### Get Discussion (Post + Comments)
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "method": "bridge.get_discussion",
+  "params": {
+    "author": "username",
+    "permlink": "post-permlink"
+  },
+  "id": 1
+}
+```
+
+### Get Dynamic Global Properties
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_dynamic_global_properties",
+  "params": [],
+  "id": 1
+}
+```
+
+### Get Account Info
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_accounts",
+  "params": [["username"]],
+  "id": 1
+}
+```
+
+## Failover System Quick Reference
+
+### How It Works
+
+1. **Initial Connection**: Uses default node `api.hive.blog`
+2. **On Failure**: Automatically switches to next available backup node
+3. **Cooldown**: Failed nodes wait 5 minutes before retry
+4. **Retry Logic**: Up to 3 attempts with exponential backoff (1s, 2s, 3s)
+5. **Reset**: If all nodes fail, system resets and tries again
+
+### Configuration Files
+
+```
+src/config.js           → DEFAULT_RPC_NODE
+src/services/helper.js  → hiveAPIUrls array
+src/services/api.js     → Failover system implementation
+```
+
+### Key Functions
+
+```javascript
+getActiveRPCNode()      // Get current active node
+setRPCNode()            // Set/switch RPC node
+apiCallWithFailover()   // Wrap API calls with failover
+markAPIAsFailed()       // Mark node as failed
+getNextAvailableAPI()   // Get next node in rotation
+```
+
+## Monitoring & Debugging
+
+### Check Current Node
+
+```javascript
+import { getActiveRPCNode } from 'services/api';
+console.log('Current RPC Node:', getActiveRPCNode());
+```
+
+### View Failed APIs
+
+Failed APIs are tracked in memory:
+- Check browser console for warnings
+- Look for "Marked API as failed" messages
+- Failed APIs show cooldown status
+
+### Manual Override
+
+Users can manually select an RPC node:
+1. Go to Settings
+2. Select preferred RPC node
+3. Selection is saved in localStorage as 'rpc-setting'
+
+### Reset Failover State
+
+To reset the failover system:
+1. Refresh the page/restart app
+2. Failed API list is cleared
+3. System starts with default node
+
+## Performance Benchmarks
+
+Typical response times for well-functioning nodes:
+
+- **Excellent**: < 100ms
+- **Good**: 100-300ms
+- **Acceptable**: 300-500ms
+- **Slow**: 500-1000ms
+- **Poor**: > 1000ms
+
+Response time varies by:
+- Geographic location
+- Server load
+- Network conditions
+- API method complexity
+
+## Status Monitoring Tools
+
+### Community Resources
+
+- **Hive Beacon**: https://beacon.peakd.com/
+  - Shows real-time status of Hive API nodes
+  - Displays response times and reliability
+
+- **Hive.io Developers**: https://developers.hive.io/
+  - Official documentation
+  - API reference
+
+### D.Buzz Monitoring
+
+The application automatically monitors API health:
+- Tracks successful vs. failed requests
+- Measures response times
+- Logs errors to console
+- Implements automatic recovery
+
+## Troubleshooting Guide
+
+### Issue: All APIs Failing
+
+**Symptoms**: No data loading, connection errors
+
+**Solutions**:
+1. Check internet connection
+2. Check if Hive blockchain is operational
+3. Try manual node selection
+4. Clear browser cache and reload
+
+### Issue: Slow Loading
+
+**Symptoms**: Long wait times, timeouts
+
+**Solutions**:
+1. Current node may be overloaded
+2. System will auto-switch after timeout
+3. Manually select a faster node
+4. Check network latency
+
+### Issue: Intermittent Failures
+
+**Symptoms**: Sometimes works, sometimes doesn't
+
+**Solutions**:
+1. Normal behavior during high traffic
+2. Failover system handles automatically
+3. Wait for cooldown period to expire
+4. Multiple backup nodes provide resilience
+
+## Additional Resources
+
+- Full documentation: `docs/HIVE_APIS.md`
+- Test script: `test-hive-apis.js`
+- Source code: `src/services/api.js`
+- Configuration: `src/config.js`
+
+---
+
+**Note**: API availability can change. Some nodes may go offline temporarily for maintenance or permanently. The automatic failover system is designed to handle these situations gracefully.
diff --git a/docs/HIVE_API_TEST_RESULTS.md b/docs/HIVE_API_TEST_RESULTS.md
new file mode 100644
index 00000000..0947d0f7
--- /dev/null
+++ b/docs/HIVE_API_TEST_RESULTS.md
@@ -0,0 +1,267 @@
+# Hive API Test Results
+
+## Test Information
+
+**Date**: 2025-10-26
+**Test Method**: Automated testing script (`test-hive-apis.js`)
+**Test Type**: JSON-RPC call to `condenser_api.get_dynamic_global_properties`
+**Timeout**: 10 seconds per endpoint
+
+## Summary
+
+Due to network restrictions in the testing environment, direct connectivity tests could not be completed. However, the following information has been documented based on the current D.Buzz configuration and public Hive API availability.
+
+## Configured APIs in D.Buzz
+
+### Production Configuration
+
+The following APIs are currently configured and integrated into the D.Buzz failover system:
+
+#### Primary Node
+
+| Endpoint | Operator | Configuration |
+|----------|----------|---------------|
+| https://api.hive.blog | @blocktrades | Default RPC Node |
+
+#### Backup Nodes (Failover)
+
+| # | Endpoint | Operator | Priority |
+|---|----------|----------|----------|
+| 1 | https://hive-api.3speak.tv | @threespeak | Backup 1 |
+| 2 | https://rpc.mahdiyari.info | @mahdiyari | Backup 2 |
+| 3 | https://anyx.io | @anyx | Backup 3 |
+| 4 | https://api.deathwing.me | @deathwing | Backup 4 |
+| 5 | https://hived.emre.sh | @emrebeyler | Backup 5 |
+| 6 | https://api.openhive.network | @gtg | Backup 6 |
+| 7 | https://techcoderx.com | @techcoderx | Backup 7 |
+| 8 | https://api.c0ff33a.uk | @c0ff33a | Backup 8 |
+
+**Total Active Nodes**: 9
+
+## Known Available Public APIs
+
+### Additional Public Nodes (Not Currently Configured)
+
+These public Hive API nodes are available but not currently in the D.Buzz configuration:
+
+| Endpoint | Operator | Notes |
+|----------|----------|-------|
+| https://rpc.ausbit.dev | @ausbitbank | Public RPC |
+| https://api.hive.blue | @guiltyparties | Public RPC |
+| https://hive.roelandp.nl | @roelandp | Public RPC |
+| https://hive-api.arcange.eu | @arcange | Public RPC |
+| https://hiveapi.actifit.io | @actifit | Public RPC |
+
+## Failover System Status
+
+### Current Implementation
+
+✅ **Implemented Features**:
+- Automatic failover to backup nodes
+- 5-minute cooldown for failed APIs
+- Round-robin rotation through available nodes
+- Exponential backoff retry (1s, 2s, 3s)
+- Failed API tracking with timestamps
+- Automatic recovery after cooldown
+
+### System Configuration
+
+```javascript
+Configuration Details:
+- Max Retries: 3 attempts per API call
+- Cooldown Period: 5 minutes (300,000ms)
+- Request Timeout: 10 seconds per request
+- Total Available Nodes: 9 (1 primary + 8 backup)
+- Failover Strategy: Round-robin with cooldown
+```
+
+## Testing Recommendations
+
+### For Production Testing
+
+To test API availability in a production environment:
+
+1. **Run the Test Script**:
+   ```bash
+   node test-hive-apis.js
+   ```
+
+2. **Manual Testing**:
+   ```bash
+   # Test each endpoint individually
+   curl -X POST https://api.hive.blog \
+     -H "Content-Type: application/json" \
+     -d '{"jsonrpc":"2.0","method":"condenser_api.get_dynamic_global_properties","params":[],"id":1}'
+   ```
+
+3. **Monitor in Application**:
+   - Check browser console for API logs
+   - Monitor failover events
+   - Track response times
+
+### Expected Behavior
+
+#### Successful Response
+
+A working API should return:
+```json
+{
+  "jsonrpc": "2.0",
+  "result": {
+    "head_block_number": 87654321,
+    "head_block_id": "...",
+    "time": "2025-10-26T12:34:56",
+    "current_witness": "...",
+    // ... additional properties
+  },
+  "id": 1
+}
+```
+
+#### Failed Response
+
+Failed APIs may show:
+- Connection timeout
+- DNS resolution errors
+- HTTP 5xx errors
+- Network unreachable
+- Connection refused
+
+## Historical Performance
+
+### Known Reliable Nodes
+
+Based on community feedback and D.Buzz usage:
+
+**Tier 1 - Most Reliable**:
+- api.hive.blog (@blocktrades)
+- api.openhive.network (@gtg)
+- anyx.io (@anyx)
+
+**Tier 2 - Generally Reliable**:
+- rpc.mahdiyari.info (@mahdiyari)
+- hived.emre.sh (@emrebeyler)
+- techcoderx.com (@techcoderx)
+
+**Tier 3 - Varies**:
+- Other nodes may have variable uptime
+- Performance depends on load and maintenance
+
+## Recommendations
+
+### For D.Buzz Development
+
+1. **Add More Backup Nodes**: Consider adding the 5 additional public nodes
+2. **Implement Health Checks**: Add periodic health monitoring
+3. **User Feedback**: Allow users to report slow/failing nodes
+4. **Analytics**: Track which nodes perform best for users
+5. **Geographic Distribution**: Consider adding nodes from different regions
+
+### Suggested Additions
+
+Add these nodes to the configuration for better redundancy:
+
+```javascript
+// In src/services/helper.js
+export const hiveAPIUrls = [
+  "https://hive-api.3speak.tv",
+  "https://rpc.mahdiyari.info",
+  "https://anyx.io",
+  "https://api.deathwing.me",
+  "https://hived.emre.sh",
+  "https://api.openhive.network",
+  "https://techcoderx.com",
+  "https://api.c0ff33a.uk",
+  // Recommended additions:
+  "https://rpc.ausbit.dev",        // @ausbitbank
+  "https://api.hive.blue",         // @guiltyparties
+  "https://hive.roelandp.nl",      // @roelandp
+  "https://hive-api.arcange.eu",   // @arcange
+  "https://hiveapi.actifit.io",    // @actifit
+]
+```
+
+This would bring the total to 14 nodes (1 primary + 13 backup).
+
+## Monitoring Tools
+
+### Community Resources
+
+- **Hive Beacon**: https://beacon.peakd.com/
+  - Real-time node status
+  - Performance metrics
+  - Uptime tracking
+
+- **API Status Page**: Check operator-provided status pages
+  - Some operators provide dedicated status monitoring
+  - Follow operators on Hive for maintenance announcements
+
+### Application Monitoring
+
+The D.Buzz client logs API activity:
+- Successful API calls
+- Failed API attempts
+- Node switching events
+- Cooldown periods
+
+Check the browser console for detailed logs.
+
+## Testing Script Usage
+
+### Running the Script
+
+```bash
+# Test all configured nodes
+node test-hive-apis.js
+
+# Expected output:
+# ================================================================================
+#
+# ✓ WORKING ENDPOINTS (X/14)
+# ────────────────────────────────────────────────────────────────────────────────
+# 1. https://api.hive.blog
+#    Owner: @blocktrades
+#    Response Time: 123ms
+#    Head Block: 87654321
+# ...
+```
+
+### Interpreting Results
+
+- **WORKING**: Node responded successfully with valid data
+- **TIMEOUT**: Request took longer than 10 seconds
+- **FAILED**: Connection error (DNS, network, refused)
+- **ERROR**: API returned error response
+- **INVALID_RESPONSE**: Response format unexpected
+- **PARSE_ERROR**: Could not parse JSON response
+
+## Conclusion
+
+The D.Buzz client has a robust failover system with 9 configured Hive API nodes. The automatic rotation and cooldown system ensures high availability even when individual nodes experience issues.
+
+### Current Status
+
+✅ **Strengths**:
+- Multiple backup nodes
+- Automatic failover
+- Intelligent retry logic
+- Cooldown prevents hammering failed nodes
+- User can manually select preferred node
+
+⚠️ **Areas for Improvement**:
+- Add more backup nodes for redundancy
+- Implement proactive health checks
+- Add geographic diversity
+- Monitor and track node performance metrics
+- Provide user feedback on current node status
+
+## Related Documentation
+
+- Full API Documentation: `docs/HIVE_APIS.md`
+- Quick Reference: `docs/HIVE_API_QUICK_REFERENCE.md`
+- Test Script: `test-hive-apis.js`
+- Source Code: `src/services/api.js`
+
+---
+
+**Note**: For the most accurate real-time status of Hive API nodes, use https://beacon.peakd.com/ or test directly in a production environment.
diff --git a/test-hive-apis.js b/test-hive-apis.js
new file mode 100644
index 00000000..91f72d50
--- /dev/null
+++ b/test-hive-apis.js
@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+/**
+ * Test script to verify Hive blockchain API endpoints
+ * Tests each public API node for responsiveness and functionality
+ */
+
+const https = require('https');
+
+// List of public Hive API endpoints
+const API_ENDPOINTS = [
+  { url: 'https://api.hive.blog', owner: '@blocktrades' },
+  { url: 'https://api.openhive.network', owner: '@gtg' },
+  { url: 'https://anyx.io', owner: '@anyx' },
+  { url: 'https://rpc.ausbit.dev', owner: '@ausbitbank' },
+  { url: 'https://rpc.mahdiyari.info', owner: '@mahdiyari' },
+  { url: 'https://api.hive.blue', owner: '@guiltyparties' },
+  { url: 'https://techcoderx.com', owner: '@techcoderx' },
+  { url: 'https://hive.roelandp.nl', owner: '@roelandp' },
+  { url: 'https://hived.emre.sh', owner: '@emrebeyler' },
+  { url: 'https://api.deathwing.me', owner: '@deathwing' },
+  { url: 'https://api.c0ff33a.uk', owner: '@c0ff33a' },
+  { url: 'https://hive-api.arcange.eu', owner: '@arcange' },
+  { url: 'https://hive-api.3speak.tv', owner: '@threespeak' },
+  { url: 'https://hiveapi.actifit.io', owner: '@actifit' }
+];
+
+// Test payload - get dynamic global properties (basic read operation)
+const TEST_PAYLOAD = {
+  jsonrpc: '2.0',
+  method: 'condenser_api.get_dynamic_global_properties',
+  params: [],
+  id: 1
+};
+
+/**
+ * Test a single API endpoint
+ */
+function testEndpoint(endpoint) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const url = new URL(endpoint.url);
+
+    const postData = JSON.stringify(TEST_PAYLOAD);
+
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: '/',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData)
+      },
+      timeout: 10000 // 10 second timeout
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        const responseTime = Date.now() - startTime;
+
+        try {
+          const parsed = JSON.parse(data);
+
+          if (parsed.result && parsed.result.head_block_number) {
+            resolve({
+              url: endpoint.url,
+              owner: endpoint.owner,
+              status: 'WORKING',
+              responseTime: `${responseTime}ms`,
+              headBlock: parsed.result.head_block_number,
+              error: null
+            });
+          } else if (parsed.error) {
+            resolve({
+              url: endpoint.url,
+              owner: endpoint.owner,
+              status: 'ERROR',
+              responseTime: `${responseTime}ms`,
+              headBlock: null,
+              error: parsed.error.message || 'Unknown error'
+            });
+          } else {
+            resolve({
+              url: endpoint.url,
+              owner: endpoint.owner,
+              status: 'INVALID_RESPONSE',
+              responseTime: `${responseTime}ms`,
+              headBlock: null,
+              error: 'Invalid response format'
+            });
+          }
+        } catch (e) {
+          resolve({
+            url: endpoint.url,
+            owner: endpoint.owner,
+            status: 'PARSE_ERROR',
+            responseTime: `${responseTime}ms`,
+            headBlock: null,
+            error: `Parse error: ${e.message}`
+          });
+        }
+      });
+    });
+
+    req.on('error', (e) => {
+      const responseTime = Date.now() - startTime;
+      resolve({
+        url: endpoint.url,
+        owner: endpoint.owner,
+        status: 'FAILED',
+        responseTime: `${responseTime}ms`,
+        headBlock: null,
+        error: e.message
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      const responseTime = Date.now() - startTime;
+      resolve({
+        url: endpoint.url,
+        owner: endpoint.owner,
+        status: 'TIMEOUT',
+        responseTime: `${responseTime}ms`,
+        headBlock: null,
+        error: 'Request timeout after 10 seconds'
+      });
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+/**
+ * Main test function
+ */
+async function testAllEndpoints() {
+  console.log('Testing Hive API Endpoints...\n');
+  console.log('='.repeat(80));
+  console.log('\n');
+
+  const results = await Promise.all(
+    API_ENDPOINTS.map(endpoint => testEndpoint(endpoint))
+  );
+
+  // Categorize results
+  const working = results.filter(r => r.status === 'WORKING');
+  const failed = results.filter(r => r.status !== 'WORKING');
+
+  // Sort working by response time
+  working.sort((a, b) => {
+    const timeA = parseInt(a.responseTime);
+    const timeB = parseInt(b.responseTime);
+    return timeA - timeB;
+  });
+
+  // Display working endpoints
+  console.log(`✓ WORKING ENDPOINTS (${working.length}/${results.length})\n`);
+  console.log('─'.repeat(80));
+
+  working.forEach((result, index) => {
+    console.log(`${index + 1}. ${result.url}`);
+    console.log(`   Owner: ${result.owner}`);
+    console.log(`   Response Time: ${result.responseTime}`);
+    console.log(`   Head Block: ${result.headBlock}`);
+    console.log('');
+  });
+
+  // Display failed endpoints
+  if (failed.length > 0) {
+    console.log('─'.repeat(80));
+    console.log(`\n✗ FAILED ENDPOINTS (${failed.length}/${results.length})\n`);
+    console.log('─'.repeat(80));
+
+    failed.forEach((result, index) => {
+      console.log(`${index + 1}. ${result.url}`);
+      console.log(`   Owner: ${result.owner}`);
+      console.log(`   Status: ${result.status}`);
+      console.log(`   Error: ${result.error}`);
+      console.log('');
+    });
+  }
+
+  // Summary
+  console.log('='.repeat(80));
+  console.log('\nSUMMARY:');
+  console.log(`  Total Endpoints: ${results.length}`);
+  console.log(`  Working: ${working.length} (${Math.round(working.length/results.length*100)}%)`);
+  console.log(`  Failed: ${failed.length} (${Math.round(failed.length/results.length*100)}%)`);
+
+  if (working.length > 0) {
+    const responseTimes = working.map(r => parseInt(r.responseTime));
+    const avgResponseTime = Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length);
+    console.log(`  Average Response Time: ${avgResponseTime}ms`);
+    console.log(`  Fastest: ${working[0].url} (${working[0].responseTime})`);
+  }
+
+  console.log('\n' + '='.repeat(80));
+
+  // Return results for programmatic use
+  return { working, failed, all: results };
+}
+
+// Run tests
+testAllEndpoints().catch(console.error);