Digital storage converter
1,024 bytes are exactly 1 KiB: convert file and memory sizes between bytes, KB, MB, GB and TB in powers of 1,000 and KiB, MiB, GiB and TiB in powers of 1,024, so advertised capacity and usable space line up. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1,024
- Source unit of 'value'
- B
- To
- KiB
- Result
- 1
- From label
- bytes
- To label
- kibibytes
- Value bytes
- 1,024
This digital storage converter turns a numeric file or memory size from one common unit into another and returns the converted magnitude with canonical unit labels. Supported units are bytes, kilobytes, megabytes, gigabytes, and terabytes using SI decimal powers of one thousand, plus kibibytes, mebibytes, gibibytes, and tebibytes using IEC binary powers of one thousand twenty-four. Conversion always bridges through bytes with fixed factors, so the same input always yields the same result with no network calls, no sampling, and no date-dependent shortcuts. Typical checks include one thousand twenty-four bytes to kibibytes, one megabyte to mebibytes, and five gigabytes to gibibytes.
What the digital storage converter returns and which units it understands
A data-size conversion answers a narrow question: given a magnitude in one storage unit, what is the equivalent magnitude in another unit that people and operating systems actually use for disks, downloads, and memory. This calculator accepts a numeric value, a source unit, and a target unit, then returns the converted result rounded to a stable precision, the canonical from and to identifiers, human-readable labels, the intermediate value in bytes, and the byte factors used for the bridge.
Canonical ids are B for bytes, KB, MB, GB, and TB for SI decimal units based on one thousand to the n, and KiB, MiB, GiB, and TiB for IEC binary units based on one thousand twenty-four to the n. Everyday spellings such as bytes, kilobyte, megabytes, gigabyte, terabytes, kibibyte, mebibyte, gibibyte, and tebibyte normalize to those ids so forms, query strings, and spreadsheets can reuse the same contract without inventing private enums.
Where digital storage conversion fits in ops, product, and software
Cloud bills and vendor specs often mix decimal gigabytes with binary gibibytes, while operating systems report mebibytes as MB in some locales, so a single deterministic converter prevents hand-calculator drift when an engineer, support agent, or buyer compares advertised capacity to usable space. Backup jobs convert snapshot sizes between megabytes and gibibytes for retention math; download managers show progress in MB while internal counters use bytes; teachers assign homework that needs a fast, offline check of kilobytes to kibibytes without trusting opaque apps that silently change the base.
Developers call the same contract from scripts to seed deterministic test vectors for file managers, to normalize user-entered limits before quota demos, or to satisfy programming-challenge statements that demand exact SI and IEC factors rather than a hand-waved estimate. Product tools use the rewrite when a learner or customer types five hundred megabytes and the UI must show mebibytes and bytes side by side.
Pair it with general multi-category unit converters when the same form must also handle length or volume, and keep this page when the search intent is specifically digital storage.
What you can do with it
Disk quotes and cloud billing
Convert between GB and GiB (or TB and TiB) when comparing advertised drive capacity, cloud storage tiers, and usable binary space.
File size and RAM labels
Normalize download sizes, memory limits, and log rotation thresholds among bytes, KB, MB, KiB, and MiB for consistent ops dashboards.
FAQ
What does the digital storage converter cost?
It is free in your browser on this page.
What happens if I send an unknown unit?
Unknown or misspelled units are never silently mapped.
Is a kilobyte 1000 or 1024 bytes?
In this converter KB is exactly 1000 bytes (SI). The binary unit for 1024 bytes is KiB (kibibyte). MB and MiB, GB and GiB, TB and TiB follow the same SI versus IEC split.
Does this convert length, area, or temperature as well?
No. This capability converts digital storage size only. For length, weight, volume, temperature, and related categories, use the general unit converter or the dedicated area converter.
Why does a drive sold in gigabytes look smaller on my computer?
Because the box counts decimal gigabytes of 1,000³ bytes, while many systems count binary gibibytes of 1,024³ bytes, sometimes still labelled GB. That is why 5 GB come out as about 4.66 GiB.
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/conv/data-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1024,"from":"B","to":"KiB"}'const res = await fetch("https://api.kit.forhosting.com/conv/data-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1024,
"from": "B",
"to": "KiB"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/data-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1024,
"from": "B",
"to": "KiB"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/data-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1024,"from":"B","to":"KiB"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1024,"from":"B","to":"KiB"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/data-size", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 1024,
"from": "B",
"to": "KiB"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.data_size",
"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.
Limits
max_abs_value | 1000000000000000000 |
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
Everyday aliases such as bytes, megabyte, kibibyte, and mebibyte normalize cleanly so forms and scripts share one contract.
What the digital storage converter returns and which units it understands
There is no marketing-style silent remap that treats a hard-drive gigabyte as a mebibyte, and no network lookup of vendor tables: the engine either multiplies and divides by fixed published factors inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing value, from, or to; non-finite numbers; magnitudes above the documented ceiling; and any unit string that is not on the supported list.
How SI and IEC factors are defined and how results stay reproducible
Optional scientific notation on the value string is allowed when it parses as a finite decimal; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong billable size. Zero is a valid value and simply yields zero in the target unit. Computation multiplies value by the source factor in bytes, then divides by the target factor: one kilobyte is exactly one thousand bytes, one megabyte one million, one gigabyte one billion, and one terabyte one trillion; one kibibyte is exactly one thousand twenty-four bytes, one mebibyte one million forty-eight thousand five hundred seventy-six, one gibibyte one billion seventy-three million seven hundred forty-one thousand eight hundred twenty-four, and one tebibyte one trillion ninety-nine billion five hundred eleven million six hundred twenty-seven thousand seven hundred seventy-six. The preferred fields are value for the size magnitude, from for the source unit, and to for the target unit, with aliases amount, size, n, quantity, and bytes_value for the value, unit, from_unit, source, and input_unit for from, and target, to_unit, output_unit, and into for to so heterogeneous clients can share one contract. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for value, result, and value_bytes, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing SI versus IEC tables yourself.
Where digital storage conversion fits in ops, product, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Homework and CI fixtures
Generate reproducible SI and IEC storage conversions for worksheets, tutoring software, and unit tests that assert fixed byte factors.
Technical questions
Which storage units are supported?
Bytes (B), kilobytes (KB), megabytes (MB), gigabytes (GB), terabytes (TB) using SI powers of 1000, and kibibytes (KiB), mebibytes (MiB), gibibytes (GiB), tebibytes (TiB) using IEC powers of 1024, including common aliases such as bytes, megabyte, and kibibyte.