Byte array to integer calculator
The bytes 0, 1, 2, 3 read big-endian make 66051, hex 0x00010203; read little-endian they make 50462976. Enter one to eight bytes, choose the byte order, and get the exact integer in decimal and hex. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bytes
- 0, 1, 2, 3
- Endianness
- Big
- Byte count
- 4
- Bit width
- 32
- Decimal
- 66051
- Hex
- 0x00010203
Binary protocols, file formats, and network packets store multi-byte integers as ordered sequences of bytes. The same four octets mean entirely different numbers under big-endian versus little-endian interpretation, so engineers and students need a deterministic way to convert a byte array into a single integer without guessing shift order. This byte array to integer calculator accepts one to eight unsigned byte values (each 0–255) and an endianness choice, then returns the combined unsigned integer as an exact decimal string, a safe JavaScript number when the value fits, and a zero-padded hexadecimal form with a 0x prefix. Use it to decode length prefixes, magic numbers, sequence counters, and multi-byte fields from hex dumps or packet captures.
How byte order turns an array into one integer
An unsigned multi-byte integer is simply a base-256 place-value number. With n bytes B0, B1, …, Bn−1 each in the range 0–255, big-endian order treats B0 as the most significant byte: the value is B0×256^(n−1) + B1×256^(n−2) + … + Bn−1×256^0. Little-endian order reverses significance so the first array element is the least significant byte: the value is B0×256^0 + B1×256^1 + … + Bn−1×256^(n−1).
Those two formulas are why the same array [0x01, 0x02, 0x03, 0x04] becomes 0x01020304 (16909060 decimal) in big-endian mode and 0x04030201 (67305985 decimal) in little-endian mode. Network protocols such as TCP/IP, most wire formats, and many file headers use big-endian (network byte order). x86 and x86-64 machine memory layouts, Windows PE fields, and large parts of the little-endian ecosystem use LSB-first storage.
This capability does not guess your platform: you must state endianness explicitly so a hex dump from a network capture and a dump from an Intel process memory window both convert correctly. The implementation accumulates the integer with exact BigInt shifts of eight bits per byte, so results stay bit-exact for every width from one through eight bytes without floating-point rounding.
Where a bytes-to-integer tool earns its keep
Protocol reverse engineering, CTF binary challenges, and embedded firmware work constantly require converting short byte runs from hex dumps into human-readable integers for lengths, offsets, timestamps, and identifiers. Teachers explaining endianness need a live oracle that flips only the byte-order flag while keeping the array fixed, so students can see why network order and host order disagree on the same memory dump.
Continuous-integration scripts that parse fixed binary headers in Node or edge workers benefit from a tiny pure function instead of pulling a full binary-parsing library for a single multi-byte field. Failed validation does not consume balance. Keep requests to at most eight bytes (the common width for uint64 fields), pin decimal and hex in your tests, and you get reproducible integer decoding for packet labs, hex-dump walkthroughs, and automation without standing up a custom shift-and-mask helper in every language you ship.
What you can do with it
Decode multi-byte fields from packet hex dumps
Paste length, port, or sequence-number bytes from a capture, choose big or little endian, and read the exact decimal and padded hex integer for the field.
Teach endianness with a fixed byte array
Keep bytes [0x12, 0x34, 0x56, 0x78] fixed, switch endianness, and show students how network order and little-endian host order produce different integers.
CI checks for binary header parsers
Assert that your language-specific unpacker matches this deterministic oracle for 1–8 byte big- and little-endian cases without floating-point drift.
FAQ
How do I convert a byte array to an integer?
Send bytes as an array of 1–8 integers from 0–255 and endianness as big or little.
What is the difference between big-endian and little-endian?
Big-endian treats the first array element as the most significant byte (network order). Little-endian treats the first element as the least significant byte (common on x86 hosts).
Why is the maximum length eight bytes?
Eight bytes cover unsigned widths through 64 bits (uint8–uint64), which matches most protocol and file-format fields. Wider multi-precision integers are outside this calculator’s scope.
Which byte order do network packets use?
Network protocols such as TCP/IP, most wire formats and many file headers use big-endian, also called network byte order. x86 memory and Windows executable headers store values little-endian, so choose the order that matches where your bytes came from.
Why does the hex result keep leading zeros?
Because it is padded to two hex digits per byte, so the width of the field stays visible: four bytes always show eight digits and a first byte of zero never disappears. The decimal result, by contrast, has no leading zeros.
Related tools
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/bytes-to-integer \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bytes":[0,1,2,3],"endianness":"big"}'const res = await fetch("https://api.kit.forhosting.com/dev/bytes-to-integer", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/bytes-to-integer",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/bytes-to-integer", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bytes":[0,1,2,3],"endianness":"big"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bytes":[0,1,2,3],"endianness":"big"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/bytes-to-integer", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.bytes_to_integer",
"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. |
Technical notes
How byte order turns an array into one integer
Optional decimal_number appears only when the unsigned result fits inside JavaScript’s safe integer range (up to 2^53−1); wider values still return the exact decimal string and hex so clients never lose low-order bits.
Input contract, response fields, and validation errors
Missing endianness or an unrecognized token likewise fails with a clear message listing the allowed values. The same bytes with little endianness yield decimal 50462976 and hex 0x03020100. Empty arrays, more than eight elements, non-integers, and values outside 0–255 fail with invalid_input naming the problem—those failures are not billed. On success the body echoes the normalized bytes array and canonical endianness (always big or little), plus byte_count, bit_width (eight times the length), decimal as a base-10 string without leading zeros except for zero itself, and hex as an uppercase 0x-prefixed string zero-padded to two digits per input byte so packet field widths stay visually stable. When the integer is at most Number.MAX_SAFE_INTEGER, decimal_number is included as a JSON number for convenience in languages that prefer numeric types; for larger unsigned values that field is omitted rather than set to null, matching the framework rule that optional outputs disappear instead of polluting clients with null. Example: bytes [0, 1, 2, 3] with endianness big yields decimal 66051, hex 0x00010203, bit_width 32, and decimal_number 66051.
Where a bytes-to-integer tool earns its keep
Documentation sites that rank for byte array to integer calculator or endianness converter gain a free browser path that matches the paid API byte-for-byte on the same module, so marketing widgets never lie about production behaviour.
Technical questions
When is decimal_number omitted?
When the unsigned result exceeds JavaScript’s safe integer range (2^53−1). The exact decimal string and hex are always present; the optional number field is omitted rather than null.
What does the byte array to integer calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.