url;key has opus/gemini

https://www.yxaiapp.com/v1;sk-jhXKp1TF206nxo1RCib1SKpZ3TpyfOTgieTsktYuuTG2W230 - gemini
http://rxrbv.top/v1;sk-c4opPskYMfvyWwdeDQ5ZTNRl45eXhalRWNReuy0NIMSqWFBc - opus, gemini
https://hiapi.online/v1;sk-A1W8L8ICl5uKCVxkBhKOYJcSs25splM4KcZ03Z7JqJSs3isz - gemini
https://api.242243.xyz/v1;sk-nQteydUIIb6AxRqVzCt5ZrzLwEanOVCAYvESjZUJHp48FN68 - gemini
https://sunlea.de/v1;sk-PtQEht8MISdBYaIkdgDL9O9BUc4HMJ6HCkXWwYWuJTu3vMdn - gemini
https://gcli.ggchan.dev;gg-gcli-W-rn_wEJqxMPzRRkRtPCpKTxZWY-rNu4cUPbpZx1JNM - gemini
https://bnwu.top/v1;sk-ldkb6FTvgHPdYlTDkfsN7NzBiAXBuV2v0rUSw53EndNMMil2 - opus, gemini
https://xg.dianhuomao.shop/v1;sk-cmw9Mmj1c2WQg1IprlZyrKL3K7FMMXnPbE1yquQDBPxIeuNa - opus, gemini
https://gcli.ggchan.dev;gg-gcli--6_nfrhB0MMygo1iTOnRyCZfdJKrLpXoEkZZuNJ8qYg - gemini
https://xg.dianhuomao.shop/v1;sk-DhBaKrGvGn1WHXH664YnM7JUt2sQGoyWsBWHp0f2mYBueAsb - opus, gemini
https://api520.pro/v1;sk-myZEwZQFOx1zjrIDLkjih9Iwzdrh9drIAfORErH9p5Z9xa4k - gemini
https://www.jiemomo.com/v1;sk-zDfZTB0U4UAcc2ESKHYhdekm1tv4k3F03536CR1YPVGa49fP - gemini
https://api.ttk.homes/v1;sk-jXKWWgNcm6czkZGdJ3Z64ydgrrUndHIZozZUhvsKOxy0v0FI - gemini
https://api520.pro/v1;sk-5W6YqFK2FKuxnteiMFXQOq9qrxh6kRmRU72DI9X5NhQk2hqn - gemini
https://bnwu.top/v1;sk-iavECQr7Ly8TD4w8qXRGJzHMUwy4Qz8J2z12A78nCOkcdSyX - opus, gemini
https://www.jiemomo.com/v1;sk-7IgzL3CfaoVxWWbYS3Ph6gk3fvpSX800PrD0VQqBn2wMxu9h - gemini
https://bnwu.top/v1;sk-j9dEU3tCPy0L39KU1ZISo9A7X8YO2DFO5jNsRTLFnbQOoDTP - opus, gemini
https://gcli.ggchan.dev/v1;gg-gcli-RFgQXicQ8Flg2v0u17UVxqkqrbjKKg9UnwY8ye9dtFo - gemini
https://linkapi.cc/v1;sk-0IShmG7ZXucdlODhC4GBouopGZJmZTPyOtOc3Z6OHaxdMbW4 - opus, gemini
https://gua.guagua.uk/v1;sk-okIbbqX7j7ULr1kf2WDaDQc3rDXczJn4RmjT440bc36SDGZo - opus
https://68886868.xyz/v1;sk-TKoBxGlFcYojSqAEehVpbmuGgsv6VChXjXX9QgJSOrULkKFJ - opus, gemini
https://gua.guagua.uk/v1;sk-D1JQLSwzYWN5RJxLZDuAmk3bJvolj8n4VGunmLjueUeZxuy4 - gemini
https://bnwu.top/v1;sk-f5qd47wvdCpWDcijkaTLTbkj5WNeXXRCm9LroFmGI1UaRIte - opus, gemini
https://fanzisima.xyz/v1;sk-gOanIqFyYDUevlzrN8RLNe6OT5BYASwBaNrIkSGfapiPjTOW - opus, gemini
https://www.xiguaai6.com/v1;sk-xR2z78c7zLLX8H527dCOZt3yKAw1AOnrHi1BUtZriygjXceQ - opus, gemini
http://rxrbv.top/v1;sk-GDqdIHSoeEVm7LLIWbRicV9knmC3uzCMzIGwzwOWKni3su1x - opus, gemini
https://max.openai365.top/v1;sk-5ZaynpwgJjRqYDOrgSMmaR0ftrHqI2LSUqGQShtORcpjbMyk - opus, gemini
https://xg.dianhuomao.shop/v1;sk-aDsEUzjgLycpqyvKC4DzAh5NqdtAvTrZ9EmhJV7kFQA3xloc - opus, gemini
https://api.qiyiguo.uk/v1;sk-UVXi6JDt3WOJR6Zu1thRgpCpnGNyqEqqpGxOL7OI2DA1mi2C - opus, gemini
https://api520.pro/v1;sk-GofZOEnEfEVcN7ydyayaACnL1NCaw411SArJvdmpfj6rd9fb - gemini
http://andaoapi.top/v1;sk-Cqx2H41tWRkMeEhFAwkMch4vG964j36bQZTBImm7zRx9d251 - opus, gemini
https://ai.nyabit.com/v1;sk-mQGUtL2P1Nb4BxzQrRNcCs6MhspFDmNrx07cpBaZ0Tcue6AU - gemini
http://rxrbv.top/v1;sk-5OBdrEplrLqnuLYAE05A1tl1zJOWNR9HXU51tlgFBWRjUKMH - opus, gemini
https://api.anay.asia/v1;sk-tDvZ3mclCJE3LYjO6XV164xM78oFOGs6Rud9rrrFm5QnHIr9 - opus, gemini
https://www.msuicode.com/v1;sk-3rGsVQK6rht3fB5WTQtztAN5FF8FmrjIaRFFqbxOQPkMGsMd - opus
https://api.chr1.com/v1;sk-rhXIyFUrNptqFszaKPYtoemj2E4FwEsMnm9fiS2dsBDK3czp - opus, gemini
https://www.jiemomo.com/v1;sk-0toZVp4egPheVLJaK5pSIZ7kE6E251MPhIicYI70kPhiB0xI - gemini
https://pro.chr1.com/v1;sk-xpant66nH6XCGKnwsmZgNNZ0HBiwzyivyKBGP3eLQCmdroGV - opus, gemini
https://gcli.ggchan.dev/v1;gg-gcli-DjmFsDT4d7SlPzgOxniCyOV_nJtUtnh-ArWngvIDi_c - gemini
https://api.mttieeo.com/v1;sk-elAgqphLjPVn4Y592BbrPXFh2osNt7IvT83ocFHgu8LE6JMz - gemini
https://gua.guagua.uk/v1;sk-UoaJIAqUJuAGAxG7qKrUNKFsgkg9N4V19cRPcwkvzvPSkZm6 - opus
https://bnwu.top/v1;sk-2BCGHu4gxt3W3vWXJzhlm8927aarK45cNiJbP98IpZOffaSj - opus, gemini

import asyncio
import aiohttp
import re
import sys
from datetime import datetime
from dataclasses import dataclass, field
from typing import Optional, List
from enum import Enum


class ModelType(Enum):
    OPUS = "opus"
    GEMINI = "gemini"


@dataclass
class ChineseKey:
    url: str
    key: str
    original_line: str
    available_models: List[ModelType] = field(default_factory=list)
    opus_model_id: Optional[str] = None
    gemini_model_id: Optional[str] = None
    is_valid: bool = False


OPUS_REGEX = re.compile(r'opus-4[.\-]6', re.IGNORECASE)
GEMINI_REGEX = re.compile(r'gemini-3.*pro(?!.*image)', re.IGNORECASE)

LINE_REGEX = re.compile(r'^(https?://[^;]+);(\S+)')


def parse_input_line(line: str) -> Optional[ChineseKey]:
    line = line.strip()
    if not line:
        return None

    match = LINE_REGEX.match(line)
    if not match:
        return None

    url = match.group(1).rstrip('/')
    key = match.group(2).strip()

    return ChineseKey(url=url, key=key, original_line=line)


def find_model_id(models: list, model_type: ModelType) -> Optional[str]:
    regex = OPUS_REGEX if model_type == ModelType.OPUS else GEMINI_REGEX

    for model in models:
        model_id = model.get('id', '')
        if regex.search(model_id):
            return model_id

    return None


async def get_models(key: ChineseKey, session: aiohttp.ClientSession) -> Optional[list]:
    url = f"{key.url}/models"
    headers = {
        "Authorization": f"Bearer {key.key}",
        "Content-Type": "application/json"
    }

    try:
        async with session.get(url, headers=headers, timeout=aiohttp.ClientTimeout(total=30)) as response:
            if response.status != 200:
                return None

            data = await response.json()

            if isinstance(data, dict):
                if 'data' in data:
                    return data['data']
                elif 'models' in data:
                    return data['models']
            elif isinstance(data, list):
                return data

            return None
    except Exception:
        return None


async def test_model(key: ChineseKey, model_id: str, session: aiohttp.ClientSession) -> bool:
    url = f"{key.url}/chat/completions"
    headers = {
        "Authorization": f"Bearer {key.key}",
        "Content-Type": "application/json"
    }

    payload = {
        "model": model_id,
        "messages": [
            {"role": "user", "content": "Hi"}
        ],
        "max_tokens": 2
    }

    try:
        async with session.post(url, headers=headers, json=payload, timeout=aiohttp.ClientTimeout(total=60)) as response:
            if response.status == 200:
                return True
            if response.status == 429:
                return True
            return False
    except asyncio.TimeoutError:
        return False
    except Exception:
        return False


async def check_key(key: ChineseKey, session: aiohttp.ClientSession, semaphore: asyncio.Semaphore, verbose: bool = False) -> Optional[ChineseKey]:
    async with semaphore:
        if verbose:
            print(f"[*] Проверка: {key.url} | {key.key}")

        models = await get_models(key, session)
        if models is None:
            if verbose:
                print(f"[-] Не удалось получить список моделей: {key.key}")
            return None

        key.opus_model_id = find_model_id(models, ModelType.OPUS)
        key.gemini_model_id = find_model_id(models, ModelType.GEMINI)

        if verbose:
            print(f"    Найдены модели - Opus: {key.opus_model_id}, Gemini: {key.gemini_model_id}")

        if not key.opus_model_id and not key.gemini_model_id:
            if verbose:
                print(f"[-] Не найдены модели opus/gemini: {key.key}")
            return None

        opus_available = False
        gemini_available = False

        if key.opus_model_id:
            opus_available = await test_model(key, key.opus_model_id, session)
            if verbose:
                print(f"    Opus ({key.opus_model_id}): {'✓' if opus_available else '✗'}")

        if key.gemini_model_id:
            gemini_available = await test_model(key, key.gemini_model_id, session)
            if verbose:
                print(f"    Gemini ({key.gemini_model_id}): {'✓' if gemini_available else '✗'}")

        if opus_available:
            key.available_models.append(ModelType.OPUS)
        if gemini_available:
            key.available_models.append(ModelType.GEMINI)

        if not key.available_models:
            if verbose:
                print(f"[-] Модели найдены, но недоступны: {key.key}")
            return None

        key.is_valid = True
        return key


def format_result(key: ChineseKey) -> str:
    models_str = ", ".join(m.value for m in key.available_models)
    return f"{key.url};{key.key} - {models_str}"


async def main():
    print("ключи в формате url;key")
    print("пустая строка для начала проверки")
    print()

    input_lines: List[str] = []

    while True:
        try:
            line = input()
            if not line:
                break
            input_lines.append(line)
        except EOFError:
            break

    if not input_lines:
        print("Нет ключей для проверки!")
        return

    keys: List[ChineseKey] = []
    for line in input_lines:
        parsed = parse_input_line(line)
        if parsed:
            keys.append(parsed)

    if not keys:
        print("не удалось распарсить ни одного ключа")
        return

    print(f"\n[*] Начинаем проверку {len(keys)} ключей")
    print("-" * 70)

    semaphore = asyncio.Semaphore(50)

    valid_keys: List[ChineseKey] = []
    invalid_count = 0

    connector = aiohttp.TCPConnector(limit=100, ssl=False)
    timeout = aiohttp.ClientTimeout(total=60)

    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
        tasks = [check_key(key, session, semaphore, verbose=True) for key in keys]
        results = await asyncio.gather(*tasks, return_exceptions=True)

        for result in results:
            if isinstance(result, Exception):
                invalid_count += 1
            elif result is None:
                invalid_count += 1
            else:
                valid_keys.append(result)

    print("\n" + "=" * 70)
    print("РЕЗУЛЬТАТЫ")
    print("=" * 70)

    output_lines = []

    if valid_keys:
        for key in valid_keys:
            line = format_result(key)
            print(line)
            output_lines.append(line)

        with open("valid_keys.txt", 'w', encoding='utf-8') as f:
            f.write("\n".join(output_lines) + "\n")
        print(f"\nРезультаты сохранены в: valid_keys.txt")
    else:
        print("Нет рабочих ключей.")

if __name__ == "__main__":
    start_time = datetime.now()
    asyncio.run(main())
    elapsed = datetime.now() - start_time
    print(f"\nВремя выполнения: {elapsed.total_seconds():.2f} сек")
Edit

Pub: 10 Feb 2026 23:32 UTC

Edit: 11 Mar 2026 10:54 UTC

Views: 4819