ForHosting KIT · Outils pour développeurs

Calculateur d’adresse IP suivante ou précédente

Ce calculateur avance ou recule d’une position dans l’espace d’adressage IPv4. Saisissez une adresse décimale pointée, choisissez le sens et obtenez l’adresse voisine ainsi que sa valeur entière non signée.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Le calcul gère chaque frontière d’octet : après 255, il reporte une unité vers la gauche ; avant 0, il effectue l’emprunt nécessaire. Il convient à la planification de sous-réseaux, aux contrôles de configuration, aux jeux de tests et aux scripts où un calcul manuel serait risqué.

Convertissez une adresse IPv4 sans calcul manuel

Une adresse IPv4 s’écrit généralement sous la forme de quatre octets décimaux séparés par des points, mais elle représente un seul entier non signé de 32 bits. Le calculateur assemble les octets, ajoute ou retranche exactement un, puis reforme la notation pointée. Ainsi, 192.168.0.255 est suivi de 192.168.1.0, et non d’un octet impossible égal à 256. Dans l’autre sens, 10.0.1.0 est précédé de 10.0.0.255. Indiquez quatre octets et choisissez suivant ou précédent. La réponse fournit également l’entier obtenu, pratique pour trier des adresses, comparer des données ou vérifier une autre implémentation. Aucun masque n’est demandé, car l’opération porte sur tout l’espace IPv4 et non sur l’appartenance à un sous-réseau donné.

Maîtrisez les reports, les emprunts et les bornes

Chaque octet IPv4 va de 0 à 255. Lors d’une incrémentation, le dernier octet augmente s’il est inférieur à 255. À 255, il revient à zéro et le report continue vers la gauche, éventuellement sur plusieurs octets : 10.255.255.255 devient 11.0.0.0. La décrémentation applique l’inverse. Un zéro devient 255 tandis qu’une unité est empruntée à gauche ; 172.16.0.0 devient donc 172.15.255.255. Le calculateur refuse de dépasser les bornes absolues. Rien ne suit 255.255.255.255 et rien ne précède 0.0.0.0. Une demande correspondante produit une erreur explicite au lieu d’un retour circulaire dangereux. Les adresses privées, réservées, de bouclage ou de diffusion restent traitées comme des valeurs IPv4 syntaxiquement valides.

Adoptez une saisie stricte pour une automatisation fiable

Seule la notation décimale pointée canonique est acceptée : quatre octets exactement, chacun compris entre 0 et 255. Les signes, espaces, éléments manquants et zéros initiaux sont refusés. Cette dernière règle évite l’ambiguïté d’anciens logiciels qui interprétaient certains éléments en octal. Le sens est suivant ou précédent ; suivant s’applique s’il est omis. Sans réseau, hasard, horloge ni état externe, l’algorithme rend toujours le même résultat pour la même entrée, dans le navigateur comme par API. Il convient donc aux scripts d’infrastructure, exports de gestion IP, tests unitaires et exemples reproductibles. Il ne détermine pas si l’adresse est attribuable dans votre sous-réseau : appliquez séparément masque et règles de réservation. Une requête API coûte $0.002, tandis que le calcul local dans le navigateur est gratuit.

Cas d’usage

Avancer dans un plan d’adressage

Passez à la valeur IPv4 voisine, y compris lorsqu’un octet final vaut 255.

Créer des données de test réseau

Produisez une adresse adjacente connue pour tester les frontières sans recopier la logique de report.

Contrôler une modification de configuration

Vérifiez l’adresse juste avant ou après un point configuré lors d’un audit ou d’une migration.

Questions fréquentes

Que se passe-t-il quand un octet atteint 255 ?

L’incrémentation reporte vers l’octet gauche : 192.168.0.255 devient 192.168.1.0.

Le calculateur peut-il reculer sur une frontière d’octet ?

Oui. La décrémentation emprunte à gauche, si bien que 10.0.1.0 devient 10.0.0.255.

Le résultat reste-t-il dans mon sous-réseau ?

Pas nécessairement. Le calcul parcourt toute la séquence IPv4 sans appliquer de masque.

Pourquoi refuser les zéros initiaux ?

La notation décimale canonique évite les interprétations ambiguës de certains anciens analyseurs.

Que se passe-t-il aux deux extrémités de l’espace IPv4 ?

Une erreur est renvoyée plutôt que de boucler au-delà de 0.0.0.0 ou 255.255.255.255.

Quel est le coût d’un calcul par API ?

Chaque requête API coûte $0.002. Le même calcul déterministe est gratuit dans le navigateur.

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

POSThttps://api.kit.forhosting.com/dev/next-ip

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/next-ip \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"address":"192.168.0.255"}'

const res = await fetch("https://api.kit.forhosting.com/dev/next-ip", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "address": "192.168.0.255"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/next-ip",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "address": "192.168.0.255"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/next-ip", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"address":"192.168.0.255"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"address":"192.168.0.255"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/next-ip", 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

{
  "address": "192.168.0.255"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.next_ip",
  "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

par requête$0.002

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.

Consulter la documentation complète du KIT →