Tester di Chiavi API AI

Non sei sicuro che la tua chiave API funzioni? Il tester gratuito di chiavi API di APIMaster ti permette di verificare qualsiasi chiave compatibile con OpenAI—controlla validità, credito e se le risposte corrispondono al comportamento atteso del modello.

Testa la Tua Chiave API Ora

Vai su APIMaster.ai API Key Tester per testare qualsiasi chiave istantaneamente nel tuo browser—nessuna registrazione richiesta.

Cosa Controlla il Tester di Chiavi API

1. Validità della chiave: la chiave è sintatticamente corretta e accettata dal fornitore?
2. Credito dell'account: l'account ha fondi per effettuare chiamate API?
3. Accesso ai modelli: a quali modelli questa chiave ha il permesso di accedere?
4. Verifica della risposta: la risposta del modello corrisponde al comportamento atteso?

Testa la Tua Chiave con Python

from openai import OpenAI

def test_api_key(api_key: str, base_url: str = "https://apimaster.ai/v1") -> dict:
    """Testa una chiave API e restituisce informazioni sullo stato."""
    client = OpenAI(api_key=api_key, base_url=base_url)
    
    results = {}
    
    # Test 1: Elenca i modelli (controllo leggero)
    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: Effettua una chiamata API minima
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": "Rispondi con '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

# Testa la tua chiave
result = test_api_key("YOUR_API_KEY")
print(result)

Test per la Validità della Chiave API Claude

import anthropic

def test_claude_key(api_key: str, base_url: str = "https://apimaster.ai") -> bool:
    """Testa una chiave API Claude (Anthropic)."""
    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": "Di' 'ok'"}],
        )
        print(f"✅ Chiave valida. Risposta: {response.content[0].text}")
        return True
    except anthropic.AuthenticationError:
        print("❌ Chiave non valida")
        return False
    except anthropic.APIStatusError as e:
        print(f"⚠️ Errore API: {e.status_code} - {e.message}")
        return False

test_claude_key("YOUR_CLAUDE_KEY")

Perché le Chiavi API Falliscono

Errore	Significato	Soluzione
401 Unauthorized	La chiave non è valida o è scaduta	Ottieni una nuova chiave dalla console
403 Forbidden	La chiave non ha il permesso per questo modello	Controlla ambito/livello della chiave
429 Too Many Requests	Limite di richieste raggiunto	Aspetta o aggiorna il livello
402 Payment Required	L'account non ha credito	Ricarica l'account
400 Bad Request	base_url errato o formato richiesta sbagliato	Controlla l'endpoint

Verifica che le Risposte di Claude Corrispondano al Modello Atteso

I servizi API multi-modello possono rendere più difficile l'ispezione della provenienza del modello, incluso il rischio di modelli falsi o sostitutivi. Il sistema di rilevamento delle impronte digitali di APIMaster verifica settimanalmente i pattern di risposta dei modelli.

Come funziona:

1. Inviamo "prompt di impronta digitale" appositamente progettati per individuare pattern di risposta specifici del modello
2. Analizziamo i pattern di risposta per confermare l'identità del modello
3. I risultati vengono pubblicati pubblicamente su https://apimaster.ai/ai-api-model-tester

# Test manuale rapido: il modello risponde correttamente ai prompt specifici di anthropic?
response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Chi ti ha creato? Rispondi esattamente in 3 parole."}],
)
# Il comportamento atteso di Claude è una risposta come "Anthropic mi ha creato"
print(response.choices[0].message.content)

Test in Batch di Più Chiavi

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, "✅ valida"
    except Exception as e:
        return label, f"❌ {type(e).__name__}"

keys_to_test = [
    ("sk-key1...", "Produzione"),
    ("sk-key2...", "Staging"),
    ("sk-key3...", "Test"),
]

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}")

Ottieni una Chiave API Verificata

Se la tua chiave attuale non funziona—o desideri dati di verifica del modello insieme all'accesso API—ottieni una chiave da APIMaster:

Domande Frequenti

Come faccio a testare se la mia chiave API funziona? Il modo più veloce: apri API Key Tester di APIMaster, inserisci la tua chiave e l'endpoint, e clicca su Test. Vedrai latenza, utilizzo dei token e la risposta del modello in pochi secondi.

Cosa causa il fallimento di una chiave API con errore 401 Unauthorized? La chiave è sbagliata (refuso, spazi extra), scaduta o legata a un URL di base diverso. Ricopiala dalla console del tuo fornitore e ricontrolla l'impostazione base_url.

Come faccio a sapere se la mia chiave API sta ottenendo il modello Claude atteso? Usa AI API Model Tester di APIMaster. Esegue un rilevamento delle impronte digitali che confronta le risposte di Claude con il comportamento specifico atteso del modello.

Posso testare più chiavi API contemporaneamente? Sì—usa lo script di test in batch nella guida sopra, che esegue i test in parallelo e riporta latenza e successo/fallimento per ogni chiave.

Qual è la differenza tra test della chiave API e verifica del modello? Il test della chiave API controlla la connettività e l'autenticazione. La verifica del modello (impronta digitale) conferma che il modello dietro l'endpoint corrisponda a quanto pubblicizzato—un controllo diverso e più approfondito.

Testa la tua chiave API gratuitamente → · Ottieni una chiave API verificata → · Visualizza i dati di verifica del modello →