Valider une clé API : préfixe, longueur et caractères
Une clé est conforme si elle commence par le préfixe attendu, compte exactement 18 caractères préfixe compris et ne contient ensuite que des lettres et des chiffres. Repérez à temps les clés tronquées, avec espaces ou du mauvais environnement. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Cet outil contrôle le préfixe requis, la longueur totale exacte et les caractères autorisés après le préfixe. Il n’effectue aucune requête réseau, ne s’authentifie auprès d’aucun fournisseur et ne prétend pas qu’une clé conforme est active. Utilisez-le pour repérer une troncature, un espace accidentel, une erreur de copier-coller ou une clé provenant du mauvais environnement avant d’enregistrer ou de déployer un secret.
Décrivez le format attendu
Placez la valeur candidate dans <code>key</code> et décrivez toutes les contraintes dans <code>pattern</code>. Le modèle exige <code>prefix</code>, <code>length</code> et <code>charset</code>. La longueur désigne toute la chaîne JavaScript, préfixe compris, et non la seule partie secrète.
Le jeu de caractères s’applique à ce qui suit un préfixe correctement reconnu. Vous pouvez aussi fournir une chaîne qui énumère chaque caractère accepté afin de représenter un alphabet propre au fournisseur. Un préfixe vide est admis, mais son champ doit rester présent.
Le modèle est obligatoire : réunir les trois contraintes empêche de confondre un simple contrôle de longueur avec une validation complète. La limite de 10,000 caractères garantit un traitement prévisible tout en restant largement suffisante.
Interprétez les contrôles séparément
La propriété <code>valid</code> n’est vraie que si les trois tests réussissent. La clé candidate n’est jamais renvoyée. Si le préfixe diffère, le contrôle porte sur toute la chaîne, car l’outil ne peut pas deviner où commencerait le secret.
Plusieurs tests peuvent donc échouer ensemble. Le résultat reste déterministe, sans horloge, hasard, état du fournisseur ni réseau. Une réponse négative signale uniquement une différence de forme ; elle ne prouve pas qu’un identifiant est révoqué ou inactif.
Contrôlez le format aux limites sûres
Ce contrôle est particulièrement utile avant l’entrée d’une clé dans un coffre de configuration, une variable de déploiement, une commande ou un formulaire d’intégration. Il détecte les défauts structurels sans transmettre le secret au service émetteur. Considérez une correspondance comme une étape préliminaire seulement : elle ne prouve ni l’existence de la clé, ni son compte, ses autorisations, son absence d’expiration ou de révocation.
Ces vérifications demandent une authentification distincte et expressément autorisée. Ne consignez pas les clés ou les entrées complètes dans les journaux, outils d’analyse, tickets ou suivis d’erreurs. Dans une interface, masquez la valeur et affichez les indicateurs et longueurs.
Définissez toujours le modèle à partir de la documentation actuelle du fournisseur et révisez-le lors d’un changement de format.
Cas d’usage
Protéger une variable de déploiement
Refusez une clé tronquée, espacée ou issue du mauvais environnement avant tout déploiement.
Contrôler un formulaire d’intégration
Expliquez précisément les écarts de préfixe, longueur et caractères sans authentification.
Vérifier une migration de configuration
Confirmez la structure des secrets migrés sans les exposer dans le résultat.
Questions fréquentes
Que comprend la longueur ?
Il s’agit de la longueur exacte de toute la chaîne JavaScript, préfixe et partie secrète compris.
Un résultat valide signifie-t-il que ma clé d’accès fonctionne ?
Non. Il confirme seulement la forme de la clé. Il ne prouve pas qu’elle existe, qu’elle appartient au bon compte, qu’elle a les bonnes autorisations ni qu’elle n’a pas expiré ou été révoquée ; seul le service émetteur peut le dire.
Ma clé est-elle envoyée quelque part pendant la vérification ?
Non. La vérification n’établit aucune connexion réseau et ne contacte pas le fournisseur qui a émis la clé. La clé n’apparaît pas non plus dans le résultat, que vous pouvez donc afficher sans exposer le secret.
Pourquoi plusieurs contrôles échouent-ils alors que seul le préfixe est faux ?
Quand le préfixe ne correspond pas, l’outil ne peut pas savoir où commence la partie secrète et examine les caractères de la clé entière. Un échec sur les caractères peut alors s’ajouter à celui du préfixe, ce qui aide à trouver la vraie erreur.
Quels jeux de caractères puis-je choisir ?
Vous pouvez choisir lettres et chiffres, minuscules et chiffres, majuscules et chiffres, hexadécimal, hexadécimal en minuscules ou Base64 adapté aux adresses web. Vous pouvez aussi saisir la liste exacte des caractères admis par votre fournisseur.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/security/api-key-format-validate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"key":"sk_live_Ab3dE5fG7h","pattern":{"prefix":"sk_live_","length":18,"charset":"alphanumeric"}}'const res = await fetch("https://api.kit.forhosting.com/security/api-key-format-validate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"key": "sk_live_Ab3dE5fG7h",
"pattern": {
"prefix": "sk_live_",
"length": 18,
"charset": "alphanumeric"
}
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/api-key-format-validate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"key": "sk_live_Ab3dE5fG7h",
"pattern": {
"prefix": "sk_live_",
"length": 18,
"charset": "alphanumeric"
}
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/api-key-format-validate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"key":"sk_live_Ab3dE5fG7h","pattern":{"prefix":"sk_live_","length":18,"charset":"alphanumeric"}}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"key":"sk_live_Ab3dE5fG7h","pattern":{"prefix":"sk_live_","length":18,"charset":"alphanumeric"}}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/api-key-format-validate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"key": "sk_live_Ab3dE5fG7h",
"pattern": {
"prefix": "sk_live_",
"length": 18,
"charset": "alphanumeric"
}
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.api_key_format_validate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Les clés API présentent souvent une forme reconnaissable, même si seul le service émetteur peut confirmer leur validité.
Décrivez le format attendu
Les valeurs prédéfinies sont <code>alphanumeric</code>, <code>lowercase_alphanumeric</code>, <code>uppercase_alphanumeric</code>, <code>hex</code>, <code>lowercase_hex</code> et <code>base64url</code>.
Interprétez les contrôles séparément
La réponse fournit également <code>has_prefix</code>, <code>length_matches</code> et <code>charset_matches</code> séparément, afin qu’une interface indique précisément la correction nécessaire. <code>actual_length</code> et <code>expected_length</code> rendent visibles une troncature ou un caractère superflu. En cas d’alphabet incorrect, <code>invalid_characters</code> répertorie une fois chaque caractère interdit, dans son ordre de première apparition.
Contrôlez le format aux limites sûres
L’algorithme déterministe fonctionne localement dans le navigateur ; l’automatisation peut utiliser l’API pour $0.002 par requête.
Questions techniques
Un résultat valide signifie-t-il que la clé API est active ?
Non. Il confirme seulement la conformité au format fourni, sans consulter le service émetteur ni s’y authentifier.
Quels jeux de caractères prédéfinis sont proposés ?
Utilisez alphanumeric, lowercase_alphanumeric, uppercase_alphanumeric, hex, lowercase_hex ou base64url, ou énumérez explicitement les caractères autorisés.
La réponse contient-elle la clé API ?
Non. Elle contient les constats et les caractères interdits distincts, mais ne reproduit jamais la valeur candidate.
Que se passe-t-il sans modèle ?
La requête échoue avec invalid_input, car le préfixe, la longueur et le jeu de caractères sont obligatoires.
Combien coûte une requête API ?
Chaque requête coûte $0.002. La même validation déterministe peut aussi s’exécuter localement dans le navigateur.