How to Fix Ollama Trading Bot Connection Failed Error: Complete Troubleshooting Guide

# API Authentication Error
ERROR: Invalid API key or secret
Status Code: 401 Unauthorized

# Network Connection Error  
ERROR: Connection timeout after 30 seconds
Status Code: Network unreachable

# Rate Limiting Error
ERROR: Too many requests
Status Code: 429 Rate limit exceeded

# Test API connection independently
import requests
import time

def test_api_connection(api_key, api_secret, exchange_url):
    """Test basic API connectivity before running bot"""
    headers = {
        'X-API-Key': api_key,
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(f"{exchange_url}/api/v1/account", 
                              headers=headers, 
                              timeout=10)
        
        if response.status_code == 200:
            print("✅ API connection successful")
            return True
        else:
            print(f"❌ API error: {response.status_code}")
            return False
            
    except requests.exceptions.Timeout:
        print("❌ Connection timeout - check network")
        return False
    except requests.exceptions.ConnectionError:
        print("❌ Network error - check internet connection")
        return False

# Run the test
test_api_connection("your-api-key", "your-secret", "https://api.exchange.com")

# Test connectivity to exchange API endpoints
ping api.binance.com
ping api.coinbase.com  
ping api.kraken.com

# Test DNS resolution
nslookup api.binance.com

# Check for packet loss
ping -c 10 api.binance.com

# View current firewall rules
netsh advfirewall firewall show rule name=all dir=out

# Add rule for trading bot (run as administrator)
netsh advfirewall firewall add rule name="Ollama Trading Bot" dir=out action=allow protocol=TCP remoteport=443

# Check iptables rules
sudo iptables -L OUTPUT

# Allow HTTPS traffic for trading
sudo iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
sudo iptables-save

# Add proxy configuration to bot settings
import requests

proxies = {
    'http': 'http://proxy.company.com:8080',
    'https': 'https://proxy.company.com:8080'
}

# Test proxy connection
try:
    response = requests.get('https://api.binance.com/api/v3/ping', 
                          proxies=proxies, 
                          timeout=10)
    print("✅ Proxy connection working")
except:
    print("❌ Proxy connection failed")

# Increase timeout values in bot config
bot_config = {
    'connection_timeout': 30,  # Increase from default 10 seconds
    'read_timeout': 60,        # Increase from default 30 seconds
    'retry_attempts': 5,       # Add automatic retries
    'retry_delay': 2           # Wait between retries
}

# Implement connection retry logic
def connect_with_retry(api_call, max_retries=5):
    """Retry API calls with exponential backoff"""
    for attempt in range(max_retries):
        try:
            return api_call()
        except ConnectionError:
            wait_time = 2 ** attempt  # Exponential backoff
            print(f"Connection failed, retrying in {wait_time} seconds...")
            time.sleep(wait_time)
    
    raise Exception("Max retries exceeded")

# Verify endpoint URLs in bot configuration
exchange_endpoints = {
    'binance': 'https://api.binance.com/api/v3/',
    'coinbase': 'https://api.pro.coinbase.com/',
    'kraken': 'https://api.kraken.com/0/public/'
}

def verify_endpoint(exchange, endpoint):
    """Test if exchange endpoint responds"""
    try:
        response = requests.get(f"{endpoint}ping", timeout=5)
        return response.status_code == 200
    except:
        return False

# Test all endpoints
for exchange, url in exchange_endpoints.items():
    status = "✅ Online" if verify_endpoint(exchange, url) else "❌ Offline"
    print(f"{exchange}: {status}")

import time
from collections import deque

class RateLimiter:
    """Prevent API rate limit violations"""
    
    def __init__(self, max_requests, time_window):
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def wait_if_needed(self):
        """Block if rate limit would be exceeded"""
        now = time.time()
        
        # Remove old requests outside time window
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # Wait if at rate limit
        if len(self.requests) >= self.max_requests:
            sleep_time = self.time_window - (now - self.requests[0])
            if sleep_time > 0:
                time.sleep(sleep_time)
        
        self.requests.append(now)

# Use rate limiter for Binance API
binance_limiter = RateLimiter(max_requests=10, time_window=60)

def make_api_call():
    """Rate-limited API call"""
    binance_limiter.wait_if_needed()
    # Make your API request here
    response = requests.get("https://api.binance.com/api/v3/ticker/price")
    return response

import logging
from datetime import datetime

# Configure detailed logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('bot_connections.log'),
        logging.StreamHandler()
    ]
)

def monitor_connection_health():
    """Log connection status every 5 minutes"""
    while True:
        try:
            # Test API connection
            response = requests.get("https://api.binance.com/api/v3/ping", timeout=5)
            if response.status_code == 200:
                logging.info("✅ API connection healthy")
            else:
                logging.warning(f"⚠️ API response code: {response.status_code}")
        
        except Exception as e:
            logging.error(f"❌ Connection failed: {str(e)}")
        
        time.sleep(300)  # Check every 5 minutes

# Run monitoring in background thread
import threading
monitor_thread = threading.Thread(target=monitor_connection_health)
monitor_thread.daemon = True
monitor_thread.start()

class MultiExchangeBot:
    """Bot with multiple exchange fallbacks"""
    
    def __init__(self):
        self.exchanges = [
            {'name': 'binance', 'url': 'https://api.binance.com'},
            {'name': 'coinbase', 'url': 'https://api.pro.coinbase.com'},
            {'name': 'kraken', 'url': 'https://api.kraken.com'}
        ]
        self.current_exchange = 0
    
    def execute_trade(self, trade_data):
        """Try trade on primary exchange, fallback if failed"""
        for attempt in range(len(self.exchanges)):
            exchange = self.exchanges[self.current_exchange]
            
            try:
                # Attempt trade on current exchange
                result = self.place_order(exchange, trade_data)
                logging.info(f"✅ Trade executed on {exchange['name']}")
                return result
                
            except ConnectionError:
                logging.warning(f"⚠️ {exchange['name']} failed, trying backup")
                self.current_exchange = (self.current_exchange + 1) % len(self.exchanges)
        
        raise Exception("All exchanges failed")

import ssl
import socket

def check_ssl_certificate(hostname, port=443):
    """Verify SSL certificate validity"""
    try:
        context = ssl.create_default_context()
        with socket.create_connection((hostname, port), timeout=10) as sock:
            with context.wrap_socket(sock, server_hostname=hostname) as ssock:
                cert = ssock.getpeercert()
                print(f"✅ SSL certificate valid for {hostname}")
                print(f"Expires: {cert['notAfter']}")
                return True
    except Exception as e:
        print(f"❌ SSL error for {hostname}: {str(e)}")
        return False

# Test exchange SSL certificates
exchanges = ['api.binance.com', 'api.coinbase.com', 'api.kraken.com']
for exchange in exchanges:
    check_ssl_certificate(exchange)

# Flush DNS cache on Windows
ipconfig /flushdns

# Flush DNS cache on macOS
sudo dscacheutil -flushcache

# Flush DNS cache on Linux
sudo systemctl restart systemd-resolved

# Configure custom DNS for API requests
import socket

# Set custom DNS servers (Google DNS)
socket.getaddrinfo = custom_getaddrinfo

def custom_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
    """Use Google DNS for name resolution"""
    import dns.resolver
    
    resolver = dns.resolver.Resolver()
    resolver.nameservers = ['8.8.8.8', '8.8.4.4']  # Google DNS
    
    try:
        answers = resolver.resolve(host, 'A')
        ip = str(answers[0])
        return [(socket.AF_INET, socket.SOCK_STREAM, 6, '', (ip, port))]
    except:
        return socket.getaddrinfo(host, port, family, type, proto, flags)

def comprehensive_connection_test():
    """Test all aspects of bot connectivity"""
    tests = []
    
    # Test 1: Basic internet connectivity
    try:
        requests.get('https://google.com', timeout=5)
        tests.append(('Internet Connection', '✅ Pass'))
    except:
        tests.append(('Internet Connection', '❌ Fail'))
    
    # Test 2: Exchange API accessibility
    exchanges = [
        'https://api.binance.com/api/v3/ping',
        'https://api.coinbase.com/v2/time'
    ]
    
    for url in exchanges:
        try:
            response = requests.get(url, timeout=10)
            status = '✅ Pass' if response.status_code == 200 else '❌ Fail'
            tests.append((f'API Access ({url})', status))
        except:
            tests.append((f'API Access ({url})', '❌ Fail'))
    
    # Test 3: API credentials
    # Add your specific API test here
    
    # Display results
    print("\n=== Connection Test Results ===")
    for test_name, result in tests:
        print(f"{test_name}: {result}")
    
    return all('✅' in result for _, result in tests)

# Run comprehensive test
if comprehensive_connection_test():
    print("\n🎉 All tests passed! Your bot should connect successfully.")
else:
    print("\n⚠️ Some tests failed. Review the errors above.")