Video bitrate for memory card
A 64 GB card with a 5 % margin leaves 60.8 GB for a 120-minute recording: enter card size, recording time, audio and margin to see the highest video bitrate that still fits before you shoot. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
When you plan a long shoot, the question is not only which codec or resolution to pick, but how hard you can push bitrate before the memory card fills early. Cameras list soft ceilings in Mbps; cards list capacity in GB; your timeline is in minutes. This required video bitrate for card calculator turns those three numbers into a single maximum sustainable video bitrate so a continuous recording of the length you want still fits. Enter card capacity, target duration, optional audio bitrate, and an optional overhead percent for filesystem or safety margin. The solver returns total and video-only Mbps using either marketing decimal gigabytes or binary gibibytes, with a short formula you can audit.
How card capacity, duration, and bitrate relate
Digital video is a stream of bits. If you know how many usable bytes the card offers and how many seconds you must record, the average total bitrate you can sustain is total bits divided by duration. Manufacturers print capacity in decimal gigabytes (one GB equals one billion bytes); operating systems often report free space in binary gibibytes (one GiB equals two to the thirtieth bytes).
Usable capacity can be reduced by an overhead percent that models filesystem tables, container headers, or a deliberate safety margin so the file never hits the wall mid-take. The result is not a guarantee that every camera menu setting will match the math—cameras also enforce profile limits, VFR ceilings, and heat cutoffs—but it is the hard storage bound: exceed that Mbps average and the target duration cannot fit on that card under the assumptions you entered.
Where a memory-card bitrate calculator earns its keep
Wedding and event shooters size dual-slot cards for multi-hour ceremonies without mid-service swaps. Documentary and run-and-gun teams compare a high-bitrate All-I preset against a lower Long-GOP option when card stock is limited in the field. Educators teaching compression show students that doubling bitrate halves continuous recording time on the same medium when capacity is fixed.
Online retailers and gear blogs that rank for video bitrate for memory card or required recording bitrate need a live tool whose free browser path matches the paid automation path byte-for-byte. Pipeline scripts can preflight a packing list: given the cards in the bag and the planned take lengths, reject a menu bitrate that cannot fit. Failed validation does not consume balance.
Pin the rounded Mbps values in tests, keep requests small, and you get reproducible storage budgets for kits, LMS demos, and edge workers without standing up media-analysis infrastructure of your own.
What you can do with it
Event and wedding card planning
Enter the largest card in the bag and the longest continuous segment; set camera bitrate at or below the returned max video Mbps so the take finishes on that card.
FAQ
How do I work out the bitrate for two hours on a 64 GB card?
Enter 64 GB, 120 minutes, 256 kbps of audio and a 5 % margin. The calculator removes the margin, leaving 60.8 GB, spreads it over 7200 seconds and subtracts the audio to give the video ceiling in Mbps.
Should I enter my card size in GB or GiB?
Use the number you actually have. The card label uses decimal gigabytes, one billion bytes each, while computers often report binary gibibytes. Pick the matching base and the calculator uses the right byte count.
Why add an overhead percentage?
It reserves space for the card's file tables, file headers or a deliberate safety margin, so a take never runs out of room halfway. With 5 %, a 64 GB card counts as 60.8 GB of usable space.
Will my camera record at exactly this bitrate?
Not necessarily. Cameras also apply their own profile limits, frame-rate ceilings and heat cutoffs. The result is the storage limit: average more than that and the recording length you asked for will not fit.
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/hobby/photo-video-bitrate-for-card \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"card_gb":64,"duration_min":120}'const res = await fetch("https://api.kit.forhosting.com/hobby/photo-video-bitrate-for-card", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"card_gb": 64,
"duration_min": 120
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/photo-video-bitrate-for-card",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"card_gb": 64,
"duration_min": 120
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/photo-video-bitrate-for-card", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"card_gb":64,"duration_min":120}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"card_gb":64,"duration_min":120}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/photo-video-bitrate-for-card", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"card_gb": 64,
"duration_min": 120
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.photo_video_bitrate_for_card",
"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 card capacity, duration, and bitrate relate
This calculator defaults to decimal marketing capacity so a sixty-four on the label maps to sixty-four times one billion bytes, and it exposes size_base equals binary when you prefer OS-style units. Audio is almost always encoded at a much lower rate than video; when you supply audio_kbps, that stream is subtracted from the total bit budget before the maximum video bitrate is reported, matching how cameras multiplex H.264 or HEVC with AAC or PCM.
Input contract, units, and response fields
Example: sixty-four GB decimal, one hundred twenty minutes, two hundred fifty-six kbps audio, five percent overhead yields a concrete video Mbps ceiling you can compare with your camera’s All-I or Long-GOP presets. POST a JSON body with card_gb, a positive capacity in gigabytes as labeled or measured, and duration_min, a positive target recording length in minutes. Optional audio_kbps defaults to zero for a pure video budget; optional overhead_pct defaults to zero and must stay under one hundred percent. Optional size_base is decimal or binary. Aliases exist for common synonyms such as capacity_gb, minutes, and audio_bitrate. Missing or non-finite values, non-positive capacity or duration, negative audio, overhead outside zero to under one hundred, or an audio stream that alone exhausts the bit budget all fail with invalid_input and are not billed. On success the body echoes the inputs, duration_seconds and duration_hours for convenience, raw_bytes and usable_bytes, usable_gb after overhead, max_total_bitrate_mbps for the combined stream, max_video_bitrate_mbps and max_video_bitrate_kbps for the video share, audio_bitrate_mbps, the size_base and bytes_per_unit used, plus formula and note strings.
Integration use cases
All-I vs Long-GOP trade-offs
Compare how a high All-I bitrate and a lower Long-GOP preset fit the same card and duration by reading max_video_bitrate_mbps against each menu option.
Kit lists and automation preflight
Scripts and packing tools call the API with card_gb and duration_min to flag shoots where planned codecs exceed sustainable storage before the crew leaves base.
Technical questions
How do I calculate max video bitrate for a memory card?
Send card_gb and duration_min (minutes). Optionally set audio_kbps and overhead_pct. The API returns max_video_bitrate_mbps = total bit budget from usable capacity minus audio, divided by duration.
Should I use decimal GB or binary GiB?
Default size_base is decimal (1 GB = 1e9 bytes), matching card labels. Use size_base binary when matching OS free-space readings in GiB (2^30 bytes).
Why subtract audio_kbps?
Cameras write audio and video into one file. Reserving audio leaves the remaining bit budget for video so the combined stream still fits the card for your duration.
What if audio uses the whole budget?
The task fails with invalid_input. Lower audio_kbps, increase card_gb, shorten duration_min, or reduce overhead_pct so video still has a positive bitrate.
What does the video bitrate for card calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.