Rate Limiting and API Key Management for Video Data APIs

class ApiKeyManager {
    private array $keys;
    private PDO $db;

    public function __construct(PDO $db) {
        $this->db = $db;
        $this->keys = $this->loadKeys();
    }

    private function loadKeys(): array {
        $stmt = $this->db->query(
            "SELECT api_key, daily_usage, last_reset 
             FROM api_keys 
             WHERE active = 1 
             ORDER BY daily_usage ASC"
        );
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    public function getNextKey(): ?string {
        foreach ($this->keys as $key) {
            // Reset counter if new day (Pacific Time, matching Google's reset)
            if ($this->isNewDay($key['last_reset'])) {
                $this->resetUsage($key['api_key']);
                return $key['api_key'];
            }
            // Skip exhausted keys
            if ($key['daily_usage'] < 9500) { // 500 unit buffer
                return $key['api_key'];
            }
        }
        return null; // All keys exhausted
    }

    public function recordUsage(string $apiKey, int $units): void {
        $stmt = $this->db->prepare(
            "UPDATE api_keys 
             SET daily_usage = daily_usage + ?, last_used = datetime('now') 
             WHERE api_key = ?"
        );
        $stmt->execute([$units, $apiKey]);
    }
}

class RateLimiter {
    private float $lastCallTime = 0;
    private float $minInterval;

    public function __construct(float $callsPerSecond = 5.0) {
        $this->minInterval = 1.0 / $callsPerSecond;
    }

    public function wait(): void {
        $elapsed = microtime(true) - $this->lastCallTime;
        if ($elapsed < $this->minInterval) {
            usleep((int)(($this->minInterval - $elapsed) * 1_000_000));
        }
        $this->lastCallTime = microtime(true);
    }
}

// Usage in fetch loop
$limiter = new RateLimiter(3.0); // 3 calls per second
$keyManager = new ApiKeyManager($db);

foreach ($regions as $region) {
    $limiter->wait();
    $apiKey = $keyManager->getNextKey();
    if (!$apiKey) {
        log_message('All API keys exhausted, stopping fetch');
        break;
    }
    $results = fetchTrending($apiKey, $region);
    $keyManager->recordUsage($apiKey, 100); // search cost
}

// BAD: 8 regions x 15 categories = 120 search calls = 12,000 units
foreach ($regions as $region) {
    foreach ($categories as $category) {
        searchVideos($region, $category); // 100 units each
    }
}

// GOOD: Use chart=mostPopular (1 unit) + videoCategoryId filter
foreach ($regions as $region) {
    // 1 unit instead of 100!
    $popular = getPopularVideos($apiKey, $region, 50);
    foreach ($categories as $category) {
        $catVideos = getPopularVideos($apiKey, $region, 50, $category);
    }
}

function makeApiCall(ApiKeyManager $km, string $url): ?array {
    $maxRetries = count($km->getKeys());
    for ($i = 0; $i < $maxRetries; $i++) {
        $key = $km->getNextKey();
        if (!$key) return null;

        $response = httpGet($url . '&key=' . $key);

        if ($response['status'] === 200) {
            return json_decode($response['body'], true);
        }

        if ($response['status'] === 403) {
            $error = json_decode($response['body'], true);
            $reason = $error['error']['errors'][0]['reason'] ?? '';

            if ($reason === 'quotaExceeded' || $reason === 'dailyLimitExceeded') {
                $km->markExhausted($key);
                continue; // Try next key
            }
        }
    }
    return null;
}

function checkQuotaHealth(PDO $db): array {
    $stmt = $db->query(
        "SELECT api_key, daily_usage,
                ROUND(daily_usage * 100.0 / 10000, 1) AS usage_pct
         FROM api_keys WHERE active = 1"
    );
    $keys = $stmt->fetchAll(PDO::FETCH_ASSOC);
    $totalUsed = array_sum(array_column($keys, 'daily_usage'));
    $totalAvailable = count($keys) * 10000;

    return [
        'keys_active'    => count($keys),
        'total_used'     => $totalUsed,
        'total_available' => $totalAvailable,
        'usage_percent'  => round($totalUsed / $totalAvailable * 100, 1),
        'per_key'        => $keys,
    ];
}