Image file size calculator
Enter width, height and bit depth and get the uncompressed size of the image: 1920 by 1080 pixels at 24 bits per pixel is 6,220,800 bytes, or 6.2208 MB. Useful before exporting a BMP or TIFF, reserving memory or choosing storage. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Width
- 1,920
- Height
- 1,080
- Bit depth
- 24
- Bytes per pixel
- 3
- Pixel count
- 2,073,600
- Megapixels
- 2.0736
- Size bytes
- 6,220,800
Uncompressed image file size is how many bytes a raster occupies when every pixel is stored at a fixed bit depth with no compression. Photographers, game artists, print technicians, and backend engineers search for an image file size calculator when they need that number before they allocate RAM, pick a storage tier, or decide whether a four-kilopixel thirty-two-bit buffer will fit on a card. JPEG, PNG, WebP, and AVIF will usually be smaller because they discard or encode redundancy; BMP, uncompressed TIFF, raw camera dumps, and GPU framebuffers follow this closed form.
How uncompressed image file size is computed
A digital image is a rectangular grid of pixels. Width is how many samples sit on one row. Height is how many rows sit in the frame.
Bit depth is how many bits describe each pixel, not each colour channel: eight bits is typical grayscale, twenty-four bits is eight-bit RGB, thirty-two bits is eight-bit RGBA, and forty-eight bits is sixteen-bit RGB. A Full HD RGB frame at 1920 by 1080 by 24 bits is 1920 times 1080 times three bytes, or 6,220,800 bytes, which is 6.2208 megabytes in SI units. A 4K UHD RGB frame at 3840 by 2160 by 24 bits is four times that pixel count and therefore four times the bytes.
Compressed codecs are out of scope because their size depends on content and encoder settings that no closed-form equation can promise. If you need a storage ceiling for a BMP bounce, an uncompressed TIFF, or a GPU upload, the raster product is the number that matters, and this calculator returns it with the byte and megabyte figures that produced it.
Where an image file size calculator earns its keep
Print shops size CMYK TIFF dumps before they RIP a poster so a three-hundred-dpi twenty-four-bit sheet does not overflow the RIP disk. Camera and drone operators estimate RAW-adjacent buffers when they only know sensor pixel count and bit depth, which this calculator turns into megabytes immediately. Educators teaching digital imaging show that doubling linear resolution quadruples file size while doubling bit depth only doubles it, and the formula field states that identity.
Failed validation does not consume balance. Keep requests small, pin the rounded megabyte values in tests, and you get reproducible storage numbers for stills pipelines, classroom demos, and edge workers without standing up media-analysis infrastructure of your own.
What you can do with it
Size a BMP or TIFF bounce before you export
Convert planned width, height, and bit depth into bytes and megabytes so the remaining disk, SD card, or object-store bucket has room for the uncompressed raster you intend to write.
FAQ
Is bit depth bits per pixel or bits per channel?
Bits per pixel. Twenty-four-bit RGB is three bytes per pixel; thirty-two-bit RGBA is four.
Does the result include JPEG or PNG compression?
JPEG, PNG, WebP, and AVIF sizes depend on the encoder and the picture and are out of scope. BMP row padding and container headers of a few dozen bytes are omitted.
How is the uncompressed size calculated?
Width times height gives the number of pixels; multiply by the bit depth and divide by eight to get bytes, then divide by one million for megabytes. Row padding and file headers are not included.
What bit depth should I enter for common images?
Use bits per pixel: 8 for typical grayscale, 24 for 8-bit RGB, 32 for 8-bit RGBA and 48 for 16-bit RGB. Packed one-bit and four-bit formats follow the same rule.
Why does doubling the resolution quadruple the size?
Because width and height both double, so the pixel count grows fourfold: a 3840 by 2160 frame needs four times the bytes of a 1920 by 1080 one. Doubling the bit depth from 24 to 48 only doubles the size.
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/date/image-file-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"width":1920,"height":1080,"bit_depth":24}'const res = await fetch("https://api.kit.forhosting.com/date/image-file-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"width": 1920,
"height": 1080,
"bit_depth": 24
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/image-file-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"width": 1920,
"height": 1080,
"bit_depth": 24
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/image-file-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"width":1920,"height":1080,"bit_depth":24}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"width":1920,"height":1080,"bit_depth":24}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/image-file-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
{
"width": 1920,
"height": 1080,
"bit_depth": 24
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.image_file_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.
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
This tool takes three positive finite numbers — width in pixels, height in pixels, and bit depth in bits per pixel — and returns size_bytes together with size_mb. The identity is width times height times bit_depth divided by eight; dividing by one million yields SI megabytes. Zero, negatives, NaN, and Infinity fail with invalid_input and are not billed.
How uncompressed image file size is computed
One byte is eight bits, so bytes per pixel is bit_depth divided by eight. The uncompressed payload is therefore width times height times bytes per pixel, which is the same as width times height times bit_depth divided by eight. Doubling bit depth from 24 to 48 doubles size_bytes when the pixel grid is unchanged. Packed one-bit and four-bit formats still follow the same identity as a theoretical payload; real BMP row padding is a few bytes per scanline and is omitted here, just as a WAV header is omitted from an audio size estimate.
Input contract, units, and response fields
Width and height are likewise positive finite numbers rather than forced integers, so fractional research rasters still compute. POST a JSON body with three required positive finite numbers: width in pixels, height in pixels, and bit_depth in bits per pixel. Aliases are accepted so common synonyms still work: w, image_width, px_width, and cols for width; h, image_height, px_height, and rows for height; bits, bpp, bits_per_pixel, depth, and color_depth for bit_depth. Each field may arrive as a JSON number or as a numeric string. Missing fields, empty strings, NaN, Infinity, zero, and negative values fail with invalid_input naming the field and are not billed. There is no enum on bit_depth because the contract is any positive finite width, including 1, 8, 16, 24, 32, and 48, not a closed list of colour-mode presets. On success the body echoes the three inputs, bytes_per_pixel, pixel_count, megapixels, size_bytes, size_kb, size_mb, size_mib, plus formula and note strings. Example: width 1920, height 1080, bit_depth 24 returns 6220800 in size_bytes and 6.2208 in size_mb. Pair the response with your own encoder if you need a compressed estimate; this endpoint reports uncompressed raster size only and does not inspect a file you already exported.
Where an image file size calculator earns its keep
Game engineers size uncompressed texture footprints for GPU upload, where a 4096 by 4096 RGBA32 atlas is a known payload before any GPU compression. Backup and ingest scripts can reject a planned BMP bounce that would exceed an object-store quota by computing size_mb first.
Integration use cases
Teach how raster storage scales
Show students that doubling linear resolution quadruples uncompressed size while doubling bit depth only doubles it, using the same formula the API returns in the formula field.
Preflight GPU, RIP, and archive quotas
Texture pipelines, print RIPs, and backup jobs can reject a planned uncompressed dump that would exceed a quota by computing size_mb first, without opening an encoder or reading a file.
Technical questions
How is image file size calculated from width, height, and bit depth?
Send positive finite numbers for width (pixels), height (pixels), and bit_depth (bits per pixel). The payload is width × height × (bit_depth / 8) bytes; size_mb is that count divided by one million.
What is the difference between size_mb and size_mib?
size_mb uses SI megabytes (1 MB = 1,000,000 bytes), the primary result. size_mib uses mebibytes (1 MiB = 1,048,576 bytes), closer to some operating-system file-size displays.
What does the image file size calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.