Check API Key Status

import requests
import time

def monitor_api_key_health(api_key: str):
    """Monitor API key health and rate limits"""
    
    while True:
        response = requests.get(
            'https://api.strike.markets/api-key/status',
            headers={'X-API-Key': api_key}
        )
        
        if response.status_code == 200:
            data = response.json()
            
            # Check if key is active
            if data['status'] != 'active':
                print("WARNING: API key is not active!")
                break
            
            # Check rate limits
            rate_limit = data['rate_limit']
            if rate_limit['remaining'] < 2:
                print(f"Rate limit warning: Only {rate_limit['remaining']} requests remaining")
                print(f"Resets at: {rate_limit['reset_at']}")
                # Wait until reset
                time.sleep(60)
            
            print(f"API Key healthy - Requests made: {data['request_count']}")
        else:
            print(f"API Key check failed: {response.json()}")
            break
        
        time.sleep(300)  # Check every 5 minutes

async function validateKeyBeforeTrading(apiKey: string): Promise<boolean> {
  try {
    const response = await fetch('https://api.strike.markets/api-key/status', {
      headers: { 'X-API-Key': apiKey }
    });
    
    if (!response.ok) {
      console.error('API key validation failed');
      return false;
    }
    
    const data = await response.json();
    
    // Check key is active
    if (data.status !== 'active') {
      console.error('API key is not active');
      return false;
    }
    
    // Check rate limits
    if (data.rate_limit.remaining < 5) {
      console.warn(`Low rate limit: ${data.rate_limit.remaining} requests remaining`);
    }
    
    return true;
  } catch (error) {
    console.error('Failed to validate API key:', error);
    return false;
  }
}

// Use before trading
if (await validateKeyBeforeTrading(process.env.STRIKE_API_KEY)) {
  // Proceed with trading
  console.log('API key validated, proceeding with trades...');
} else {
  console.error('Cannot trade - API key validation failed');
}

class RateLimitManager:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.strike.markets"
    
    def check_rate_limit(self):
        """Check current rate limit status"""
        response = requests.get(
            f"{self.base_url}/api-key/status",
            headers={'X-API-Key': self.api_key}
        )
        
        if response.status_code == 200:
            data = response.json()
            return data['rate_limit']
        return None
    
    def wait_if_needed(self):
        """Wait if rate limit is exhausted"""
        rate_limit = self.check_rate_limit()
        
        if rate_limit and rate_limit['remaining'] == 0:
            reset_time = datetime.fromisoformat(rate_limit['reset_at'].replace('Z', '+00:00'))
            wait_seconds = (reset_time - datetime.now(timezone.utc)).total_seconds()
            
            if wait_seconds > 0:
                print(f"Rate limit reached. Waiting {wait_seconds:.1f} seconds...")
                time.sleep(wait_seconds + 1)  # Add 1 second buffer
                return True
        return False
    
    def safe_request(self, method, endpoint, **kwargs):
        """Make a request with rate limit checking"""
        self.wait_if_needed()
        
        response = requests.request(
            method,
            f"{self.base_url}{endpoint}",
            headers={'X-API-Key': self.api_key, **kwargs.get('headers', {})},
            **{k: v for k, v in kwargs.items() if k != 'headers'}
        )
        
        return response

# Usage
manager = RateLimitManager(os.environ['STRIKE_API_KEY'])

# Safe request that respects rate limits
response = manager.safe_request(
    'POST',
    '/long',
    json={'margin': '100', 'leverage': 10, 'symbol': 'BTC-USD'}
)

async function checkKeyAge(apiKey) {
  const response = await fetch('https://api.strike.markets/api-key/status', {
    headers: { 'X-API-Key': apiKey }
  });
  
  if (response.ok) {
    const data = await response.json();
    const createdAt = new Date(data.created_at);
    const ageInDays = (Date.now() - createdAt) / (1000 * 60 * 60 * 24);
    
    if (ageInDays > 90) {
      console.warn(`API key is ${ageInDays.toFixed(0)} days old. Consider rotating for security.`);
      return true;
    }
    
    console.log(`API key age: ${ageInDays.toFixed(0)} days`);
    return false;
  }
}

// Check key age periodically
setInterval(async () => {
  if (await checkKeyAge(process.env.STRIKE_API_KEY)) {
    // Send notification to rotate key
  }
}, 24 * 60 * 60 * 1000); // Check daily