Testeur de clés API IA

Vous ne savez pas si votre clé API fonctionne ? Le testeur de clés API gratuit d'APIMaster vous permet de vérifier toute clé compatible OpenAI — vérifiez sa validité, son solde, et si les réponses correspondent au comportement attendu du modèle.

Testez votre clé API maintenant

Rendez-vous sur APIMaster.ai API Key Tester pour tester n'importe quelle clé instantanément dans votre navigateur — aucune inscription requise.

Ce que vérifie le testeur de clés API

1. Validité de la clé : la clé est-elle syntaxiquement correcte et acceptée par le fournisseur ?
2. Solde du compte : le compte dispose-t-il de fonds pour les appels API ?
3. Accès aux modèles : à quels modèles cette clé a-t-elle la permission d'accéder ?
4. Vérification des réponses : la réponse du modèle correspond-elle au comportement attendu ?

Testez votre clé avec Python

from openai import OpenAI

def test_api_key(api_key: str, base_url: str = "https://apimaster.ai/v1") -> dict:
    """Test an API key and return status info."""
    client = OpenAI(api_key=api_key, base_url=base_url)
    
    results = {}
    
    # Test 1: List models (lightweight check)
    try:
        models = list(client.models.list())
        results["valid"] = True
        results["model_count"] = len(models)
        results["models"] = [m.id for m in models[:5]]
    except Exception as e:
        results["valid"] = False
        results["error"] = str(e)
        return results
    
    # Test 2: Make a minimal API call
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": "Reply with 'ok'"}],
            max_tokens=5,
        )
        results["callable"] = True
        results["response"] = response.choices[0].message.content
    except Exception as e:
        results["callable"] = False
        results["call_error"] = str(e)
    
    return results

# Test your key
result = test_api_key("YOUR_API_KEY")
print(result)

Test de validité de la clé API Claude

import anthropic

def test_claude_key(api_key: str, base_url: str = "https://apimaster.ai") -> bool:
    """Test a Claude (Anthropic) API key."""
    client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
    try:
        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=5,
            messages=[{"role": "user", "content": "Say 'ok'"}],
        )
        print(f"✅ Key valid. Response: {response.content[0].text}")
        return True
    except anthropic.AuthenticationError:
        print("❌ Invalid key")
        return False
    except anthropic.APIStatusError as e:
        print(f"⚠️ API error: {e.status_code} - {e.message}")
        return False

test_claude_key("YOUR_CLAUDE_KEY")

Pourquoi les clés API échouent

Erreur	Signification	Correctif
401 Unauthorized	La clé est invalide ou expirée	Obtenez une nouvelle clé depuis la console
403 Forbidden	La clé n'a pas la permission pour ce modèle	Vérifiez la portée/niveau de la clé
429 Too Many Requests	Limite de débit atteinte	Attendez ou augmentez le niveau
402 Payment Required	Le compte n'a pas de solde	Rechargez le compte
400 Bad Request	Mauvaise base_url ou format de requête	Vérifiez le point d'accès

Vérifiez que les réponses de Claude correspondent au modèle attendu

Les services API multi-modèles peuvent rendre plus difficile l'inspection de la provenance des modèles, y compris le risque de modèle faux ou de substitution. Le système de détection d'empreinte d'APIMaster vérifie les schémas de réponse des modèles chaque semaine.

Comment ça fonctionne :

• Nous envoyons des « prompts d'empreinte » soigneusement conçus qui ciblent les schémas de réponse spécifiques au modèle
• Nous analysons les schémas de réponse pour confirmer l'identité du modèle
• Les résultats sont publiés publiquement sur https://apimaster.ai/ai-api-model-tester

# Quick manual test: does the model respond correctly to anthropic-specific prompts?
response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Who made you? Reply in exactly 3 words."}],
)
# Expected Claude behavior is a response such as "Anthropic made me"
print(response.choices[0].message.content)

Test par lots de plusieurs clés

import concurrent.futures

def test_key_quick(key_info):
    api_key, label = key_info
    client = OpenAI(api_key=api_key, base_url="https://apimaster.ai/v1")
    try:
        client.models.list()
        return label, "✅ valid"
    except Exception as e:
        return label, f"❌ {type(e).__name__}"

keys_to_test = [
    ("sk-key1...", "Production"),
    ("sk-key2...", "Staging"),
    ("sk-key3...", "Testing"),
]

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as pool:
    for label, status in pool.map(test_key_quick, keys_to_test):
        print(f"{label}: {status}")

Obtenez une clé API vérifiée

Si votre clé actuelle ne fonctionne pas — ou si vous souhaitez obtenir des données de vérification de modèle en plus de l'accès API — obtenez une clé auprès d'APIMaster :

Questions fréquentes

Comment tester si ma clé API fonctionne ? Le moyen le plus rapide : ouvrez APIMaster's API Key Tester, entrez votre clé et votre point d'accès, puis cliquez sur Test. Vous verrez la latence, l'utilisation des tokens et la réponse du modèle en quelques secondes.

Qu'est-ce qui provoque l'échec d'une clé API avec 401 Unauthorized ? La clé est incorrecte (faute de frappe, espace supplémentaire), expirée ou liée à une base_url différente. Recopiez-la depuis la console de votre fournisseur et vérifiez le paramètre base_url.

Comment savoir si ma clé API obtient bien le modèle Claude attendu ? Utilisez AI API Model Tester d'APIMaster. Il exécute une détection d'empreinte qui compare les réponses de Claude avec le comportement spécifique attendu du modèle.

Puis-je tester plusieurs clés API à la fois ? Oui — utilisez le script de test par lots dans le guide ci-dessus, qui exécute les tests en parallèle et rapporte la latence et le succès/échec pour chaque clé.

Quelle est la différence entre le test de clé API et la vérification de modèle ? Le test de clé API vérifie la connectivité et l'authentification. La vérification de modèle (empreinte) confirme que le modèle derrière le point d'accès correspond à ce qui est annoncé — un contrôle différent et plus approfondi.

Testez votre clé API gratuitement → · Obtenez une clé API vérifiée → · Consultez les données de vérification de modèle →