Convertisseur IPv4 en hexadécimal et binaire par octet
Ce convertisseur IPv4 en hexadécimal transforme une adresse décimale pointée en formats hexadécimal et binaire de largeur fixe, tout en conservant sa structure de quatre octets indispensable en réseau.
Lancer gratuitement
Saisissez une adresse comme 192.168.1.10 pour afficher chaque octet décimal avec son équivalent hexadécimal sur deux chiffres et binaire sur huit bits, ainsi que des formes regroupées prêtes à comparer aux captures de paquets, journaux, listes d’accès et fichiers de configuration de routeurs. Le résultat, présenté octet par octet, simplifie l’examen des notations de bas niveau sans conversions de base répétitives.
Lisez la conversion octet par octet
Une adresse IPv4 se compose de quatre valeurs non signées sur huit bits, écrites en décimal et séparées par des points. Le convertisseur valide d’abord cette structure, puis transforme chaque octet indépendamment. Le nombre décimal 192 devient C0 en hexadécimal et 11000000 en binaire ; le nombre décimal 1 devient 01 en hexadécimal et 00000001 en binaire. Les largeurs fixes sont essentielles : sans le zéro initial, les petites valeurs peuvent donner l’impression qu’un champ de paquet est plus court et compliquer les comparaisons visuelles. Le résultat présente donc un enregistrement pour chaque position, avec sa valeur décimale, sa valeur hexadécimale sur deux caractères et sa valeur binaire sur huit caractères. Il fournit aussi les formes hexadécimale pointée, hexadécimale compacte et binaire pointée. Utilisez les enregistrements d’octets pour apprendre ou vérifier un champ, et les représentations regroupées pour rapprocher une valeur d’une capture, d’un export d’équipement, d’un journal de bas niveau ou d’une note de protocole. Après validation, l’adresse est normalisée afin que la sortie reste prévisible pour les scripts et les comparaisons golden.
Pourquoi une validation IPv4 stricte est nécessaire
Un outil réseau doit refuser une saisie ambiguë plutôt que de faire une supposition silencieuse. Ce convertisseur exige exactement quatre octets décimaux, chacun compris entre 0 et 255 inclus. Il n’accepte ni signe, ni préfixe hexadécimal, ni composant manquant, ni point supplémentaire, ni zéro initial comme dans 001. Certains logiciels anciens interprètent les zéros initiaux comme une notation octale, tandis que d’autres systèmes les considèrent comme une simple présentation décimale ; leur refus empêche donc un même texte de désigner des adresses différentes selon l’environnement. Les espaces autour de l’adresse sont supprimés, mais aucun espace n’est admis à l’intérieur. La validation est uniquement syntaxique et numérique : le convertisseur ne prétend pas qu’une adresse est routable publiquement, attribuée, joignable, privée, multidiffusion ou sûre. Des valeurs comme 0.0.0.0 et 255.255.255.255 sont des représentations valides à quatre octets et peuvent être converties, même si leur sens opérationnel dépend du contexte. Une valeur refusée produit une erreur de saisie typée, jamais une conversion partielle ou trompeuse.
Exploitez ces formats pour les paquets et les routeurs
L’hexadécimal est compact et correspond directement aux octets ; les vidages de paquets et outils de débogage affichent donc souvent les adresses par groupes comme C0 A8 01 0A ou sous la forme d’une valeur continue. Le binaire rend visibles les limites de bits, les masques et les préfixes : la même adresse devient quatre groupes de huit bits, ce qui permet de distinguer les bits du préfixe de sous-réseau de ceux de la partie hôte. La sortie pointée conserve les limites entre octets, tandis que le champ hexadécimal compact facilite les recherches dans les journaux sans séparateurs. Vérifiez toujours la notation attendue par le système de destination avant de coller un résultat ; certains formats de configuration demandent des préfixes 0x, des espaces, des deux-points ou un entier sur 32 bits plutôt que les représentations proposées ici. Cette capacité fournit volontairement des valeurs neutres de largeur fixe et ne réécrit aucun fichier de configuration. Son exécution déterministe n’utilise ni réseau, ni hasard, ni horloge, ni requête DNS, ni service externe ; elle convient ainsi aux contrôles reproductibles dans le navigateur et aux flux automatisés via l’API à $0.002 par requête.
Cas d’usage
Retrouver une adresse dans une capture
Convertissez une IPv4 décimale pointée en hexadécimal aligné sur les octets et comparez-la directement aux données brutes du paquet.
Examiner les bits d’un sous-réseau
Affichez chaque octet sur huit bits afin de mieux distinguer les limites du préfixe et de la partie hôte.
Rechercher dans les exports et journaux de routeurs
Utilisez la sortie hexadécimale pointée ou compacte pour repérer une adresse dans les systèmes sans notation décimale.
Questions fréquentes
Combien coûte la conversion ?
Elle est gratuite dans le navigateur, et chaque requête via l’API coûte $0.002.
Les octets hexadécimaux sont-ils complétés ?
Oui. Chaque octet hexadécimal comporte exactement deux caractères ; le nombre décimal 1 est donc renvoyé sous la forme 01.
Les octets binaires sont-ils complétés ?
Oui. Chaque octet binaire comporte exactement huit bits, ce qui préserve les limites d’octets d’IPv4.
Pourquoi les zéros initiaux sont-ils refusés ?
Les logiciels ont historiquement interprété ces nombres de différentes manières. Leur refus évite les adresses ambiguës.
L’outil vérifie-t-il si une adresse est publique ou joignable ?
Non. Il valide et convertit uniquement la notation IPv4, sans requête DNS, routage, propriété, géolocalisation ni test d’accessibilité.
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/dev/ipv4-to-hex \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"192.168.1.10"}'const res = await fetch("https://api.kit.forhosting.com/dev/ipv4-to-hex", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "192.168.1.10"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/ipv4-to-hex",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "192.168.1.10"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/ipv4-to-hex", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"192.168.1.10"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"192.168.1.10"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/ipv4-to-hex", 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
{
"text": "192.168.1.10"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.ipv4_to_hex",
"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. |