Dummy File Generator

Generate dummy files of an exact byte size — images, audio, video, PDFs, text, and more — entirely in your browser. Handy for testing upload form size limits. Files are never sent to a server.

Last updated: 2026-09-04

Format

Format	Extension	MIME Type	Spec Limit	Notes
Text (TXT)	`.txt`	`text/plain`	Effectively unlimited	Padded with readable, repeating text
CSV	`.csv`	`text/csv`	Effectively unlimited	Dummy tabular data with a header row
JSON	`.json`	`application/json`	Effectively unlimited	Padded into a single string field
Binary (BIN)	`.bin`	`application/octet-stream`	Effectively unlimited	Arbitrary bytes cycling through 0x00–0xFF
Image (PNG)	`.png`	`image/png`	Effectively unlimited	Valid 1x1 image + padding chunk
Audio (WAV)	`.wav`	`audio/wav`	4 GiB	Silent PCM data (genuinely playable)
Video (MP4)	`.mp4`	`video/mp4`	Effectively unlimited	Real recording in supporting browsers, structure-only placeholder otherwise
Video (WebM)	`.webm`	`video/webm`	Effectively unlimited	A genuinely recorded few-second animation (supporting browsers only)
PDF	`.pdf`	`application/pdf`	Effectively unlimited	Valid, blank single-page PDF
ZIP	`.zip`	`application/zip`	4 GiB	Uncompressed, single-entry archive

What Is a Dummy File Generator?

When you build an upload feature, you need to confirm that its size limits and extension checks actually behave as intended. That requires a file that is "exactly a given number of bytes, yet still valid for its format" — and files like that are surprisingly hard to have on hand. This tool generates text, images, audio, video, PDFs, ZIP archives, and more, each at precisely the size you request.

Every file it produces is valid data that conforms to its format's specification. Many formats set aside regions a parser is allowed to skip, and the tool uses exactly those regions to pad the size, so nothing opens as corrupted. All processing happens inside your browser, and nothing you generate is ever sent to a server. Note that WAV and ZIP are capped at 4 GiB by their format specifications.

How to Generate a Dummy File

Choose a file format Pick whichever format your test target accepts. If you want to test extension or MIME type checks, choose that exact format.
Specify the size Enter a number and a unit. If the limit you're testing is "10MB," note that the boundary shifts depending on whether that means 10,000,000 or 10,485,760 bytes.
Set a file name You can include the extension in the name you choose. Change this if you want to test filename-based rejection rules.
Generate and download Press "Generate" to build the file. Larger sizes take longer, and you can cancel at any point while it's running.

Tips for getting more out of it

Upload form validation logic often checks extension, MIME type, and file size as three separate steps. Because this tool generates files that are valid in every other respect, you can isolate and test the size limit alone.
A "10MB limit" can mean 10,000,000 bytes (10⁶) in one implementation and 10,485,760 bytes (2²⁰) in another. The unit selector lets you pick either base, so you can test both the exact boundary value and one byte past it.
Chrome and Edge stream data directly to your chosen drive, so files tens of gigabytes in size can be generated without straining memory. Firefox and Safari assemble the file in memory first, which imposes a practical size limit.
In supporting browsers, video (MP4/WebM) is actually recorded as a few seconds of animation using the browser's built-in encoder, so it genuinely plays when opened. Everything else — the padding that makes up most of the file, and the contents of the other image/audio formats — is a dummy. The goal is purely to test size, extension, and MIME type validation.

Ways to Use Dummy Files

Boundary-value testing for upload limits

Create a file exactly at the limit and another one byte over it, then try both. This confirms whether the error message appears exactly where the spec says it should.

Verifying extension and MIME type checks

Generate both an allowed format and a forbidden one and submit each, so you can tell which rule is actually doing the rejecting.

Checking behavior with large transfers

With files several gigabytes in size, you can verify that progress indicators, timeouts, and resuming an interrupted transfer all work correctly — without needing to source real data.

Estimating storage and bandwidth needs

Placing a file of the expected size lets you measure actual storage consumption and transfer time before you commit to a design.

Terms Around File Validation

MIME type: A string that identifies a file's kind, written like image/png, and commonly used to decide whether an upload is allowed.
Boundary-value testing: A testing technique that checks the exact edge of a limit along with the values just inside and just outside it, since bugs cluster there.
Padding: Meaningless data added purely to reach a target size. It's placed in regions the format allows parsers to skip, so the file stays intact.
GiB vs. GB: A GiB is 1,073,741,824 bytes; a GB is 1,000,000,000 bytes. This gap is a common cause of mismatched size-limit interpretations.
Streaming write: Writing data to its destination incrementally rather than all at once, which lets even very large files be handled without loading the whole thing into memory.

Frequently Asked Questions

No. Generation happens entirely inside your browser, and the content is never sent to a server.

Yes — in supporting browsers (e.g. Chrome), the browser's built-in encoder actually records a few seconds of animation, so it plays when you open it. Most of the file is padding added to hit the exact size. MP4 automatically falls back to a structure-only placeholder in browsers that don't support recording, so generation itself never fails. WebM can only be selected in browsers that support recording.

Both formats store the file size in a field that the specification fixes at 32 bits (a maximum of about 4.29 GB). That is not a limitation of our implementation — it is a ceiling built into the format specification itself.

TXT, CSV, JSON, BIN, PNG, PDF, MP4, and WebM have no upper limit in their format specification, so with the latest version of Chrome or Edge (which support writing directly to disk) you can generate extremely large files.

Side Note — Where "Valid" Ends and "Corrupt" Begins

Most file formats set aside regions that a parser is explicitly allowed to skip — PNG's unknown chunks, MP4's free box, and WebM's Void element are all examples. These were designed from the start as space reserved for future extensions that today's parsers are meant to ignore, so padding them out never corrupts the file.

For video, we make the file genuinely playable by placing real footage before the padding. Hand-writing bit-level codec encoding ourselves is too hard to guarantee correct, so instead we let the browser's own built-in encoder (the MediaRecorder API) record a few seconds of a canvas animation, then append padding afterward. It's a way to reconcile "always return a guaranteed-valid file" with "the user actually wants to see a video."

Interestingly, a ZIP file is designed so that reading only the "central directory" at the very end reveals the full list of its contents. This is said to be a holdover from the magnetic-tape era, when archives were read from the tail — and it is still why a single file can be pulled out of a huge ZIP almost instantly today.

Browse all trivia