IPv4 to hexadecimal converter
This IPv4 to hexadecimal converter turns a familiar dotted-decimal address into fixed-width hexadecimal and binary forms, while preserving the four-octet structure that matters in network work.
Run — free
Enter an address such as 192.168.1.10 to see every decimal octet beside its two-digit hex and eight-bit binary equivalent, plus joined forms ready to compare with packet captures, logs, access lists, and router configuration files. The clear byte-by-byte result makes low-level notation easier to inspect without doing repeated base conversions manually.
Read the conversion one octet at a time
An IPv4 address is four unsigned eight-bit values written in decimal and separated by dots. The converter validates that structure first, then transforms each octet independently. Decimal 192 becomes hexadecimal C0 and binary 11000000; decimal 1 becomes hexadecimal 01 and binary 00000001. Fixed widths are important here. Without the leading zero, small values can make a packet field look shorter than it really is and make visual comparisons harder. The result therefore shows a record for every position with its decimal, two-character hexadecimal, and eight-character binary value. It also provides dotted hexadecimal, compact hexadecimal, and dotted binary forms. Use the octet records when learning or checking one field, and use the joined representations when matching a value found in a capture, device export, low-level log, or protocol note. The original address is normalized after validation, so the output stays predictable for scripts and golden comparisons.
Why strict IPv4 validation matters
Network tools should reject ambiguous input instead of quietly guessing. This converter requires exactly four decimal octets, each in the inclusive range from 0 through 255. It does not accept signs, hexadecimal prefixes, missing components, extra dots, or leading zeros such as 001. Leading zeros have been interpreted as octal by some historical software, while other systems treat them as ordinary decimal formatting; rejecting them prevents the same text from meaning different addresses in different environments. Surrounding whitespace is harmless and is trimmed, but whitespace inside an address is not accepted. The validation is purely syntactic and numeric: the converter does not claim that an address is publicly routable, assigned, reachable, private, multicast, or safe to use. Values such as 0.0.0.0 and 255.255.255.255 are valid four-octet representations and can be converted, even though their operational meaning depends on context. A rejected value returns a typed input error rather than a partial or misleading conversion.
Use the formats in packet and router work
Hexadecimal is compact and maps cleanly to bytes, which is why packet dumps and debugging tools often show addresses as groups such as C0 A8 01 0A or as one continuous value. Binary makes bit boundaries, masks, and prefixes explicit: the same address becomes four groups of eight bits, allowing you to see which bits belong to a subnet prefix and which belong to the host portion. The dotted output keeps octet boundaries visible, while the compact hexadecimal field is convenient for searching logs that omit separators. Always check the notation expected by the destination system before pasting a result; some configuration formats want 0x prefixes, spaces, colons, or a 32-bit integer rather than the representations returned here. This capability deliberately supplies neutral, fixed-width values and does not rewrite a configuration file. It runs deterministically without network access, random values, clocks, DNS lookups, or external services, making it suitable for repeatable browser checks and automated API workflows at $0.002 per request.
What you can do with it
Match an address in a packet capture
Convert a dotted IPv4 address into byte-aligned hex and compare it directly with raw packet data.
Inspect subnet bits
View every octet as eight bits so prefix and host boundaries are easier to reason about.
Search router exports and logs
Use dotted or compact hexadecimal output to find an address in systems that do not display decimal notation.
FAQ
How much does the conversion cost?
It is free in the browser, and an API request costs $0.002.
Are hexadecimal octets padded?
Yes. Every hexadecimal octet has exactly two characters, so decimal 1 is returned as 01.
Are binary octets padded?
Yes. Every binary octet has exactly eight bits, preserving the byte boundaries of IPv4.
Why are leading zeros rejected?
Different software has historically interpreted leading-zero numbers differently. Rejecting them avoids ambiguous addresses.
Does this check whether an address is reachable or public?
No. It validates and converts IPv4 notation only; it performs no DNS, routing, ownership, geolocation, or reachability lookup.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your 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)Example request
{
"text": "192.168.1.10"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.ipv4_to_hex",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |