Real Content Detection
Reads the file's actual byte signature — the same technique behind the Unix file command — instead of trusting the filename.
Developer Tool
MIME Type Checker
Find out what a file actually is by reading its real content, not just its name — plus a searchable lookup of 100+ MIME types by extension. Nothing is ever uploaded.
- Real Content Detection
- Extension Mismatch Warnings
- 100+ Type Lookup
- Nothing Uploaded, Ever
Check a MIME Type
Drop a file here, or click to choose one
Any file type — images, documents, archives, audio, video, fonts
Nothing is uploaded. The file is read locally in your browser and never leaves your device.
Common
| Extension | MIME Type | Category | Description |
|---|
Features
Reads the File, Not Just the Name
Most "MIME checkers" just look up the extension. This one actually inspects the bytes.
Mismatch Warnings
Flags it automatically when a file's extension doesn't match what's actually inside — useful for spotting renamed or disguised files.
100+ Type Lookup
Search by extension, MIME string, or keyword across images, documents, audio, video, archives, fonts, and code.
Nothing Ever Uploaded
Your file never leaves your browser. Detection happens entirely client-side, in JavaScript, on your own machine.
Shareable Report
Copy a full diagnostic summary — filename, size, and all three readings — for a bug report or support ticket.
Instant, No Dependencies
No frameworks, no upload wait, no account. Drop a file or type a search — the result appears immediately.
How It Works
Two Ways to Get an Answer
- 1
Have a File?
Drop it in. The tool reads its byte signature and tells you what it really is — plus what the browser and extension think it is.
- 2
Just Need a Reference?
Switch to Look Up and search any extension or MIME string across 100+ known types.
- 3
Copy and Go
Copy the exact MIME string, or the full report, straight into your code, header, or ticket.
FAQ
Frequently Asked Questions
A MIME type (Multipurpose Internet Mail Extensions type) is a short label — like
image/png or application/pdf — that tells a browser, server, or email client what kind of data a file contains, so it knows how to handle it. It's made of two parts separated by a slash: a general type (image, text, application) and a specific subtype (png, html, pdf).Drop the file into the Detect From File tab above. It reads the first few bytes of the file directly in your browser and matches them against known file signatures — the same technique tools like the Unix
file command use — rather than trusting the file's name or extension, which can be wrong or deliberately misleading.No, and this trips people up constantly. The extension (
.pdf) is just part of the filename — it's a hint, not a guarantee. The MIME type (application/pdf) describes the actual format of the data. You can rename report.pdf to report.txt and the extension changes instantly, but the bytes inside — and therefore the real MIME type — don't change at all.application/json is the standard MIME type for JSON data — API responses, config files, package.json, and any request body sent with Content-Type: application/json. If a server sends JSON with the wrong Content-Type (like text/plain), some strict HTTP clients and browser fetch() configurations will refuse to parse it automatically.text/plain is the MIME type for unformatted text with no markup — .txt files, plain log output, and the generic fallback browsers use when they can't confidently identify a text-based file as anything more specific. It's also the default Content-Type many misconfigured servers send by accident, which is a common source of bugs when the browser expected something else, like JavaScript or JSON.Browsers report the type your operating system associates with a file's extension via the File API — not the file's actual content. If a file was renamed, downloaded with the wrong extension, or your OS has no association for it, the browser-reported type can be blank, generic, or simply wrong. That's exactly why content-based detection (reading the actual bytes) is more reliable than trusting
file.type alone.Yes — nothing stops you from renaming any file's extension, and the operating system won't complain. Most of the time this is harmless (a careless rename), but it's also how some malicious files try to disguise themselves as something safer, like an executable renamed to look like a
.jpg. Comparing the content-detected type against the extension is a quick, genuinely useful sanity check before opening or sharing a file you don't fully trust.Yes — the file you select is never uploaded anywhere. It's read locally using your browser's File API, and the byte-signature matching happens entirely in JavaScript running on your own machine. Nothing about the file's name, content, or metadata is sent to any server, including ours.
application/octet-stream is the standard fallback for "unknown binary data" — it tells the receiving end not to assume anything and just treat it as raw bytes. For text you can't classify more specifically, text/plain is the safer default. Avoid guessing a more specific type than you're sure of; an incorrect MIME type can cause a browser to render or execute content in ways you didn't intend.What Is a MIME Type?
A MIME type is a two-part label — type/subtype — that identifies what kind of data a file or HTTP response body contains. image/png, application/pdf, and text/html are all MIME types. Browsers, mail clients, and servers use this label to decide what to do with data: render it as a webpage, display it as an image, offer it as a download, or refuse to run it at all. The name comes from Multipurpose Internet Mail Extensions, the 1990s email standard MIME types were originally designed for, before the web adopted the same system for HTTP.
MIME Type vs. File Extension — They're Not the Same Thing
A file extension is metadata attached to a filename. A MIME type describes the actual content. In well-behaved situations they agree — a .png file really is image/png — but the operating system trusts the extension by default, which means it can be wrong. Change a file's extension and its name-based type "changes" instantly with zero effect on the bytes inside it. This is exactly why the Detect From File tab above reads the file's real content instead of asking your OS what it thinks the extension means.
| File Extension | MIME Type | |
|---|---|---|
| What it is | Part of the filename (.pdf) | A label describing actual content (application/pdf) |
| Can it be wrong? | Trivially — anyone can rename a file | Only if mislabeled by whoever set it |
| Determined by | Whatever the file was last named | The file's actual byte structure, or a server's Content-Type header |
| Used by | Operating systems, for default app associations | Browsers, servers, and HTTP itself |
How Browsers and Servers Actually Use MIME Types
Every HTTP response includes a Content-Type header — the server's declaration of the MIME type for whatever it's sending back. The browser trusts that header (within limits) to decide how to render the response: a text/html response gets parsed as a webpage, an image/png response gets decoded as an image, and an application/octet-stream response typically triggers a download prompt instead of inline rendering. Modern browsers also enforce MIME type sniffing protections — if a response is served with X-Content-Type-Options: nosniff and a mismatched Content-Type, the browser will refuse to guess its way around the mistake, which is a deliberate security measure against MIME-confusion attacks.
Common MIME Types Reference
| MIME Type | Typical Extension | Used For |
|---|---|---|
text/html | .html | Web pages |
text/css | .css | Stylesheets |
text/javascript | .js | Scripts, ES modules |
application/json | .json | API data, config files |
image/jpeg | .jpg, .jpeg | Photos, compressed images |
image/png | .png | Lossless images, transparency |
image/svg+xml | .svg | Vector graphics |
application/pdf | Documents | |
application/zip | .zip | Compressed archives |
audio/mpeg | .mp3 | Compressed audio |
video/mp4 | .mp4 | Video |
application/octet-stream | (any) | Generic/unknown binary data |
The full, searchable list — 100+ types across images, audio, video, documents, archives, fonts, and code — is in the Look Up tab above.
When Developers Actually Need This
- File upload validation — checking that a user-uploaded "image" is really an image before you process or serve it, not just trusting its extension or the client-reported
file.type. - Setting HTTP response headers — serving a file with the wrong
Content-Typeis one of the most common causes of "it works locally but breaks in production" bugs, especially with JS modules and JSON APIs. - Debugging a build or CDN misconfiguration — a static host serving
.jsfiles astext/plainwill silently breaktype="module"script imports in every modern browser. - Email attachments — MIME types are literally why the standard is called MIME; attachment handling still depends on the type declared in the message.
- Security review — confirming a file's real type before opening or forwarding it, especially when the extension alone can't be trusted.
Common MIME Errors and Misconfigurations
If you've ever seen a browser console error like Refused to apply style from '...' because its MIME type ('text/html') is not a supported stylesheet MIME type, and strict MIME checking is enabled, you've hit a real MIME misconfiguration — usually a server returning an HTML error page (like a 404) with a 200 status and an HTML Content-Type, in response to a request for a CSS or JS file. The browser correctly refuses to execute or apply it, because doing otherwise would be a security risk. The fix is almost always on the server or CDN side: make sure static assets are actually being found and served with the Content-Type that matches their real format, not silently falling back to an error page.
Need to check something else about a file? Our Hash Generator confirms a file's integrity (useful right alongside a MIME check when verifying a download), and the Base64 Encoder/Decoder is where MIME types show up again inside data: URIs, like data:image/png;base64,.... For the fuller story on where MIME types came from and how browsers use them, see our MIME type guide.