Audio file size calculator
One CD-quality minute at 44100 Hz, 16-bit, stereo takes 10,584,000 bytes, or 10.584 MB, before any compression. Enter duration, sample rate, bit depth and channels to size a drive before you record. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Duration
- 60
- Sample rate
- 44,100
- Bit depth
- 16
- Channels
- 2
- Bytes per sample
- 2
- Bitrate bps
- 1,411,200
- Bitrate kbps
- 1,411.2
- Size bytes
- 10,584,000
Uncompressed audio file size is the product of how long you record, how often you sample, how many bits sit in each sample, and how many channels you keep. Enter duration in seconds, sample rate in hertz, bit depth in bits per sample, and channel count. Compressed codecs will be smaller; this tool answers the WAV and AIFF question that archival, mixing, and broadcast pipelines still ask first.
How uncompressed PCM file size is computed
Linear pulse-code modulation stores a stream of samples. Each sample is a fixed-width integer or floating-point value; bit depth is that width in bits. Sample rate is how many of those values arrive per second on one channel.
Channel count multiplies the stream: mono is one independent sample train, stereo is two, and a 5.1 stem is six. Duration is how many seconds the train lasts. Dividing by eight converts bits to bytes.
A compact-disc minute at 44100 hertz, 16-bit, stereo is 44100 times two bytes times two channels times 60 seconds, or 10,584,000 bytes, which is 10.584 megabytes. A 48 kilohertz, 24-bit, stereo minute is larger because both the rate and the bytes per sample grew. This formula does not model MP3, AAC, Opus, or FLAC compression, and it does not add RIFF or AIFF container headers of a few dozen bytes.
Those headers are negligible next to minutes of PCM; compressed codecs depend on content and encoder settings that no closed-form size equation can promise. If you need a storage ceiling for mixing or archival WAV, the PCM product is the number that matters, and this calculator returns it with the bitrate that produced it.
Where an audio file size calculator earns its keep
Studios and podcast producers size session drives before tracking so a two-hour 48 kilohertz 24-bit stereo capture does not overflow the remaining disk. Educators teaching digital audio show that doubling sample rate or doubling bit depth doubles file size when duration and channels stay fixed, which this calculator makes immediate. Video editors who extract PCM from camera files need a storage bound for the WAV they will bounce, not a bitrate guess from a compressed codec.
Live-sound and broadcast teams estimate overnight archive footprints for multichannel stems before they commit a recorder format. Failed validation does not consume balance. Keep requests small, pin the rounded megabyte values in tests, and you get reproducible storage numbers for DAW templates, LMS demos, and edge workers without standing up media-analysis infrastructure of your own.
What you can do with it
Size a tracking session before you record
Convert planned duration, sample rate, bit depth, and channel count into megabytes so the session drive, SD card, or object-store bucket has room for the WAV you intend to capture.
FAQ
Does the result include a WAV header or compression?
WAV or AIFF headers of a few dozen bytes are omitted. MP3, AAC, Opus, and FLAC sizes depend on the encoder and are out of scope.
What happens if a value is zero, negative, or missing?
Every input must be a positive finite number. Invalid input is not billed.
How big is one minute of CD-quality audio?
10.584 MB. At 44100 Hz, 16-bit and two channels, each second uses 1411.2 kbps, and 60 seconds add up to 10,584,000 bytes of uncompressed audio.
Why does my computer show a smaller number of megabytes?
Because the main result uses megabytes of one million bytes, while some operating systems divide by 2 to the 20th power. The calculator gives both figures, so you can compare them with what your disk reports.
What happens to the size if I double the sample rate or bit depth?
It doubles, as long as duration and channel count stay the same. File size grows in direct proportion to each of the four values, so stereo is twice mono and a 5.1 mix has six channels.
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/audio/audio-file-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}'const res = await fetch("https://api.kit.forhosting.com/audio/audio-file-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/audio-file-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/audio-file-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/audio-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
{
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.audio_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.
Limits
max_mb | 200 |
max_minutes | 180 |
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 audio file size calculator takes those four numbers and returns the PCM payload in megabytes so you can size disks, upload quotas, and session templates before you hit record. Every input must be a positive finite number; zero, negatives, NaN, and Infinity fail with invalid_input and are not billed. The solver reports size_mb using SI megabytes of one million bytes, plus size_bytes, size_mib, and the linear PCM bitrate.
How uncompressed PCM file size is computed
The exact payload in bytes is therefore duration times sample_rate times bit_depth divided by eight times channels. Dividing the byte count by one million yields size_mb, the SI megabyte used as the primary result of this endpoint. Dividing by two to the twentieth yields size_mib, which is closer to what some operating systems still print as MB.
Input contract, units, and response fields
Channel count is likewise a positive finite number rather than a named layout, so mono, stereo, and multichannel stems share one field. POST a JSON body with four required positive finite numbers: duration in seconds, sample_rate in hertz, bit_depth in bits per sample, and channels. Aliases are accepted so common synonyms still work: duration_seconds, seconds, length, and time for duration; sample_rate_hz, sr, hz, and sampling_rate for sample_rate; bits, bit_depth_bits, depth, and bits_per_sample for bit_depth; channel_count, ch, n_channels, and num_channels for channels. 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 8, 16, 24, and 32, not a closed list of studio presets. On success the body echoes the four inputs, bytes_per_sample, bitrate_bps and bitrate_kbps for the uncompressed stream, size_bytes, size_kb, size_mb, size_mib, plus formula and note strings. Example: duration 60, sample_rate 44100, bit_depth 16, channels 2 returns 10.584 in size_mb. Pair the response with your own encoder if you need a compressed estimate; this endpoint reports uncompressed PCM size only and does not inspect a file you already recorded.
Where an audio file size calculator earns its keep
Backup and ingest scripts can reject a planned capture that would exceed an object-store quota by computing size_mb first.
Integration use cases
Teach how PCM storage scales
Show students that doubling sample rate or bit depth doubles uncompressed size when duration and channels are held fixed, using the same formula the API returns in the formula field.
Preflight upload and archive quotas
Ingest scripts and backup jobs can reject a planned PCM bounce that would exceed a quota by computing size_mb first, without opening an encoder or reading a file.
Technical questions
How is audio file size calculated from duration and format?
Send positive finite numbers for duration (seconds), sample_rate (Hz), bit_depth, and channels. The payload is duration × sample_rate × (bit_depth / 8) × channels 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 audio 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.