Base64 Overhead & File Size Calculator
Compute exact Base64 encoded character length, byte overhead (+33.33%), padding characters, and check JSON/HTTP payload limits for AWS Lambda, DynamoDB, and API Gateway.
How Base64 Size Expansion & Padding Formulas Work
Base64 encoding translates arbitrary binary octets into a safe 64-character ASCII alphabet (A–Z, a–z, 0–9, +, and /) so binary payloads can travel cleanly inside JSON APIs, HTML Data URIs, email MIME bodies, and JWTs. Because each Base64 character encodes exactly 6 bits of binary information while an input byte contains 8 bits, every 3 input bytes (24 bits) expand into 4 ASCII output characters (32 bits).
This 4-to-3 expansion introduces a fixed +33.33% size overhead for inputs whose byte length is divisible by 3, and slightly more on tiny inputs due to "=" padding characters that align the output to a multiple of 4 characters. URL-Safe Base64 (RFC 4648 Section 5) replaces "+" with "-", "/" with "_", and typically omits trailing "=" padding, saving up to 2 bytes per encoded token.
Understanding exact Base64 expansion is critical when designing serverless architectures. For example, AWS Lambda enforces a strict 6 MB synchronous invocation payload ceiling. Once you Base64-encode a binary file inside a JSON body, the maximum raw file size that fits safely inside 6 MB drops to approximately 4.49 MB. Similarly, Amazon DynamoDB enforces a 400 KB item limit, capping Base64-encoded binary attributes near 299 KB raw.
Exact Base64 Length & Padding Formula (RFC 4648)
Given an input payload of n raw bytes, standard Base64 output length is strictly deterministic and always a multiple of 4 bytes.
Standard Base64 Length = ceil(n / 3) * 4
Padding Characters (=) = (3 - (n mod 3)) mod 3
URL-Safe Unpadded Len = ceil(n / 3) * 4 - ((3 - (n mod 3)) mod 3)
Overhead Percentage = ((EncodedBytes - n) / n) * 100 // Approaches +33.333% Code Equivalents (Python & JavaScript / Node.js)
import base64
import math
def base64_metrics(raw_bytes: int) -> dict:
encoded_len = math.ceil(raw_bytes / 3) * 4
padding = (3 - (raw_bytes % 3)) % 3
overhead_pct = ((encoded_len - raw_bytes) / raw_bytes * 100) if raw_bytes else 0.0
return {
"raw_bytes": raw_bytes,
"encoded_chars": encoded_len,
"padding": padding,
"url_safe_chars": encoded_len - padding,
"overhead_pct": round(overhead_pct, 2),
}
data = b'{"service":"devpayload"}'
encoded = base64.b64encode(data).decode("ascii")
print(base64_metrics(len(data)), encoded) function calculateBase64Metrics(rawBytes) {
const encodedChars = Math.ceil(rawBytes / 3) * 4;
const paddingChars = (3 - (rawBytes % 3)) % 3;
const overheadPct = rawBytes > 0 ? ((encodedChars - rawBytes) / rawBytes) * 100 : 0;
return {
rawBytes,
encodedChars,
paddingChars,
urlSafeChars: encodedChars - paddingChars,
overheadPct: Number(overheadPct.toFixed(2)),
};
}
const payload = Buffer.from('{"service":"devpayload"}', 'utf8');
console.log(calculateBase64Metrics(payload.length));
console.log(payload.toString('base64')); Frequently Asked Questions
Why does Base64 always increase file size by roughly 33.33%? +
Base64 maps every 3 bytes (24 bits) of raw binary data into 4 ASCII characters (6 bits each, stored as 4 bytes). Dividing 4 by 3 yields 1.3333, representing a 33.33% size expansion plus up to 2 bytes of "=" padding.
What is the maximum raw file size I can send in a 6 MB AWS Lambda JSON payload? +
Because Base64 expands data by 33.33% and JSON/HTTP wrappers add extra bytes, a raw file larger than ~4.49 MB will exceed AWS Lambda's 6 MB synchronous invocation limit. For larger files, use S3 presigned URLs instead of inline Base64.
How is URL-Safe Base64 different from standard Base64? +
URL-Safe Base64 (RFC 4648 Section 5) substitutes "+" with "-" and "/" with "_" so encoded strings do not break URL query parameters or filenames, and commonly strips trailing "=" padding characters.
Does dropping a file here upload it to any server? +
Never. File sizes and Base64 previews are computed strictly in your browser using File.arrayBuffer() and native Web APIs.