Vérifiez si une méthode HTTP est sûre ou idempotente
Sachez si une méthode peut être répétée sans surprise : put, saisi avec des espaces, est lu comme PUT, non sûre mais idempotente, donc l’envoyer deux fois a le même effet voulu que l’envoyer une fois. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Sûre et idempotente : deux promesses différentes
Une méthode sûre sert à obtenir des informations ou à demander quelles options propose un serveur, pas à y changer quoi que ce soit. HEAD, OPTIONS et TRACE font partie de ce groupe, et toute méthode sûre est aussi idempotente. Idempotente est une promesse plus large : envoyer plusieurs fois le même message produit le même effet voulu qu’un seul envoi. PUT et DELETE tiennent cette promesse sans être sûres, car enregistrer de nouveau le même contenu ou supprimer de nouveau le même élément n’ajoute aucun effet nouveau.
Quand vérifier avant de relancer
La question compte surtout quand une connexion se coupe et que l’on ne sait pas si le serveur a reçu le message. Avant d’activer les relances automatiques pour une méthode, vérifiez-la ici : vous obtenez la méthode en majuscules, si elle est sûre, si elle est idempotente et une courte étiquette qui résume le tout. La casse et les espaces en trop ne comptent pas, donc put devient PUT. Une erreur courante consiste à croire qu’idempotente veut dire inoffensive : DELETE modifie bien des données, simplement pas deux fois. Les noms inconnus ou inventés sont refusés plutôt que devinés.
Interprétez correctement les nouvelles tentatives
L’idempotence est particulièrement utile pour déterminer si un client automatisé peut renouveler une requête après une panne de connexion. Le client peut ignorer si le serveur a reçu la première tentative ; répéter une méthode idempotente préserve l’effet recherché de la requête. Cela ne garantit ni des codes d’état identiques ni des corps de réponse identiques.
Par exemple, un premier DELETE peut supprimer une ressource et indiquer une réussite, tandis qu’un second DELETE identique peut signaler que la ressource n’existe plus ; l’état final recherché reste néanmoins le même. PUT présente la même propriété lorsque les requêtes répétées conservent la cible et la représentation.
Cas d’usage
Révisez la logique de répétition
Contrôlez une méthode configurée avant d’autoriser les nouvelles tentatives automatiques après une panne de transport ambiguë.
Questions fréquentes
Pourquoi DELETE est-elle idempotente si le second essai peut renvoyer un autre état ?
L’idempotence concerne l’effet recherché sur le serveur, et non des réponses identiques. Des demandes de suppression répétées visent le même état final de la ressource.
Les noms de méthode en minuscules sont-ils acceptés ?
Oui. Le vérificateur retire les espaces périphériques et convertit le nom fourni en majuscules avant de le classer.
Comment les méthodes WebDAV ou personnalisées sont-elles traitées ?
Elles sont rejetées comme inconnues. Leurs propriétés doivent provenir de la spécification ou du contrat applicatif qui les définit.
Quelle différence entre une méthode sûre et une méthode idempotente ?
Une méthode sûre ne fait que consulter des informations et ne demande aucun changement au serveur. Une méthode idempotente peut modifier des choses, mais l’envoyer deux fois a le même effet voulu qu’une seule fois. PUT et DELETE sont idempotentes sans être sûres.
Quelles méthodes sont reconnues ?
Les neuf méthodes standard du protocole web et de la spécification de PATCH, comme PUT, PATCH, DELETE, HEAD, OPTIONS et TRACE. La casse et les espaces autour du nom sont ignorés : put est donc lu comme PUT.
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/dev2/http-method-idempotent-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"method":"PUT"}'const res = await fetch("https://api.kit.forhosting.com/dev2/http-method-idempotent-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"method": "PUT"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/http-method-idempotent-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"method": "PUT"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/http-method-idempotent-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"method":"PUT"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"method":"PUT"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/http-method-idempotent-check", 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
{
"method": "PUT"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.http_method_idempotent_check",
"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
Classez une méthode HTTP standard selon les propriétés de sûreté et d’idempotence définies par la sémantique HTTP. Saisissez une méthode comme GET, POST, PUT, PATCH ou DELETE pour obtenir son nom normalisé, deux résultats booléens distincts et une classification synthétique. Le vérificateur reconnaît les neuf méthodes définies dans les principales spécifications relatives à la sémantique HTTP et à PATCH, ignore les espaces périphériques et la casse, puis rejette les noms inconnus au lieu de supposer les propriétés d’une méthode d’extension.
Distinguez la sûreté de l’idempotence
La sûreté et l’idempotence correspondent à deux garanties différentes. Une méthode sûre sert à récupérer des informations ou à communiquer des options, et non à demander une modification d’état au serveur d’origine. L’idempotence couvre un champ plus large : plusieurs requêtes identiques ont le même effet recherché sur le serveur qu’une seule requête. PUT et DELETE sont idempotentes sans être sûres, car remplacer plusieurs fois une représentation par la même représentation ou demander plusieurs fois la suppression de la même ressource n’ajoute pas un nouvel effet recherché à chaque exécution. GET, HEAD, OPTIONS et TRACE sont sûres. La sémantique HTTP précise également que toute méthode sûre est idempotente ; ces méthodes reçoivent donc la classification combinée `safe_and_idempotent`. La réponse fournit `safe` et `idempotent` séparément afin que votre code de règles n’ait pas à déduire une propriété d’une étiquette. Elle renvoie aussi le champ `classification`, pratique pour l’affichage, la journalisation ou une condition simple. Ces propriétés décrivent la sémantique normalisée des requêtes et ne garantissent pas qu’une implémentation particulière soit exempte de défauts ou d’effets secondaires accessoires.
Interprétez correctement les nouvelles tentatives
POST et PATCH sont classées comme ni sûres ni idempotentes dans leur définition générale. Une API particulière peut concevoir une opération POST ou PATCH répétable, éventuellement grâce à une clé d’idempotence ou à une requête conditionnelle, mais ce contrat applicatif ne modifie pas la propriété normalisée par défaut de la méthode. Utilisez ce résultat comme base protocolaire, puis appliquez les garanties supplémentaires que l’API appelée documente explicitement.
Validez le nom avant d’appliquer une règle
Deviner les propriétés d’une méthode d’extension à partir de son nom pourrait autoriser une répétition dangereuse ou bloquer une opération valide. Si votre système emploie une telle méthode, consultez la spécification qui l’enregistre ou la définit et traitez-la au moyen d’une règle explicite. L’algorithme n’effectue aucune requête réseau et n’observe aucun serveur, aucune route, aucun cache, aucun proxy ni aucun corps réel. Le vérificateur accepte les noms standard CONNECT, DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT et TRACE. L’entrée est débarrassée de ses espaces périphériques puis convertie en majuscules ; des valeurs comme ` get ` et `patch` sont donc normalisées sans changer de sens. Toute autre valeur produit une erreur `invalid_input`. Cette rigueur est importante, car les jetons de méthode HTTP sont extensibles : WebDAV et d’autres protocoles définissent des méthodes supplémentaires, tandis que des API privées peuvent introduire leurs propres jetons. Déterministe, il convient aux linters, aux contrôles de documentation d’API, à la configuration des mécanismes de répétition et aux outils pédagogiques dans le navigateur. Le navigateur et le gestionnaire API partagent la même logique ; une requête API applique le tarif de base publié de $0.002.
Cas d'intégration
Contrôlez la documentation d’une API
Comparez les méthodes choisies pour les points d’accès aux documents qui déclarent une opération sûre ou idempotente.
Enseignez la sémantique HTTP
Présentez séparément les propriétés de sûreté et d’idempotence des méthodes courantes à l’aide d’une consultation déterministe.
Questions techniques
Toute méthode sûre est-elle également idempotente ?
Oui. La sémantique HTTP définit les méthodes sûres comme idempotentes ; GET, HEAD, OPTIONS et TRACE possèdent donc les deux propriétés.
PATCH est-elle idempotente ?
PATCH n’est pas idempotente par défaut. Une API peut définir une opération PATCH répétable, mais il s’agit alors d’une garantie propre à l’application.