MIME Type Lookup — 150+ file extensions ↔ Content-Types

A MIME type lookup answers a question every web developer runs into sooner or later: what content type does this file actually need? This tool maps over 150 common file extensions to their correct MIME type (and back again) across images, video, audio, documents, archives, code, and fonts, so you can stop guessing and get the exact value your server, API, or upload form needs.

Arb Digital's developers reach for a MIME type lookup constantly — configuring file uploads, setting response headers for downloadable assets, debugging why a browser is trying to render a file instead of downloading it, or writing server config that serves the right Content-Type for every static asset on a site. This version runs entirely client-side with the full mapping embedded in the page, so results are instant.

What This MIME Type Lookup Does

Type a file extension like .png or a MIME type like image/png into the search box and the reference table below filters live to show every match — search works in both directions, so you can look up an extension to find its MIME type, or paste a MIME type you found in a response header to find which extensions map to it. Click Look Up to populate the summary panel with the category, the general type (the part before the slash), the subtype (the part after the slash), and whether the format is text-based or binary. Every mapping is drawn from an embedded JavaScript lookup table covering the extensions developers encounter most often, grouped into images, video, audio, documents, archives, code and markup, and fonts.

How to Use the MIME Type Lookup

1. Search by extension. Type a file extension, with or without the leading dot (e.g. docx or .docx), and the table filters to show its MIME type.
2. Search by MIME type. Type a full or partial MIME type, like video/ to see every video format, or application/json for an exact match.
3. Click Look Up for an exact match to see the type, subtype, category, and whether the format is typically text-based (which affects things like character encoding and compressibility) or binary.
4. Scroll the full table to browse every entry grouped roughly by category, useful when you're not sure of the exact extension or MIME string you need.
5. Copy the exact MIME string into your server configuration, upload validation logic, or HTTP response header — small differences (like a missing +xml suffix) can break parsing.

What a MIME Type Actually Is

MIME stands for Multipurpose Internet Mail Extensions, a standard that originally described email attachment formats and was later adopted by HTTP to describe the format of any data sent over the web. Every MIME type has the structure type/subtype — for example image/png has the general type image and the specific subtype png, while application/vnd.openxmlformats-officedocument.wordprocessingml.document (a modern Word file) has the general type application and a long, vendor-specific subtype. The full, authoritative registry of MIME types is maintained by IANA, and MDN's MIME types guide is the most practical developer-facing reference for how they're used on the web specifically.

On the web, MIME types travel in the Content-Type HTTP header. When a server sends a file, it includes a line like Content-Type: image/jpeg or Content-Type: application/json; charset=utf-8, and the receiving browser or application uses that value — not the file extension — to decide how to interpret the bytes that follow. This is a critical distinction: extensions are a filesystem convention for humans, while MIME types are the actual protocol-level instruction that determines behavior.

Why the Content-Type Header Breaks Downloads and Uploads

When a server sends the wrong MIME type, the browser trusts the header over the file's actual content or extension in most cases, which produces a specific and very common family of bugs. Serve a PDF with Content-Type: text/plain and the browser may try to display raw binary garbage as text instead of opening it in a PDF viewer. Serve a downloadable ZIP archive with Content-Type: text/html and some browsers will attempt to render it as a webpage rather than prompting a save dialog. Upload endpoints have the mirror-image problem: many APIs validate the incoming Content-Type header before even looking at the file itself, so a client that sends an image with the generic application/octet-stream type instead of the specific image/jpeg or image/png can get rejected by a strict validator, even though the file itself is perfectly valid.

A related and equally common failure mode is a missing or incorrect charset parameter on text-based types. A response declared as text/html without a charset=utf-8 parameter can render special characters, accented letters, or emoji as garbled symbols in some browser and locale combinations, even though the underlying bytes were perfectly correct UTF-8 — the browser simply guessed the wrong encoding because the header didn't specify one.

Text-Based vs. Binary MIME Types

One useful distinction this tool surfaces is whether a format is text-based or binary. Text-based formats — like text/html, text/css, application/json, and text/csv — are made of readable characters in a known encoding, which means they compress extremely well with gzip or Brotli, can be diffed line by line in version control, and can be edited directly in a plain text editor. Binary formats — like image/png, video/mp4, and application/zip — pack data far more densely for their specific purpose but generally can't be meaningfully edited as text, don't diff cleanly, and often don't benefit much from additional server-side compression since they're frequently already compressed internally (which is why re-gzipping a JPEG or a ZIP file rarely saves meaningful space and can even slightly increase size).

Configuring MIME Types on Your Own Server

Most web servers ship with a built-in mapping of extensions to MIME types and apply it automatically, but it's worth knowing where that mapping lives in case you ever need to add or correct an entry. Apache typically reads its extension-to-type mapping from a mime.types file (often at /etc/mime.types or bundled inside the Apache install) referenced by the mod_mime module, or you can override individual types directly in an .htaccess file with an AddType directive. Nginx keeps its own mime.types file, usually included near the top of nginx.conf, and falls back to application/octet-stream for any extension it doesn't recognize — which is a common reason a newer file format silently downloads instead of displaying inline until the server config is updated. Node.js frameworks like Express typically delegate this to a small library (commonly one built on the same public MIME database referenced by IANA) when serving static files, so adding support for an unusual extension usually means updating that library's data or registering a manual override rather than hand-writing header logic yourself.

Cloud storage and CDN platforms add another layer to get right: when you upload a file directly via an API rather than through a browser form, many services store whatever Content-Type you explicitly set at upload time and will keep serving that value indefinitely, even if it's wrong. This is a common cause of images or PDFs uploaded through a script or CLI tool ending up served as generic application/octet-stream long after the fact — always set the correct MIME type explicitly at upload time rather than assuming a storage provider will infer it correctly from the extension alone.

Common MIME Type Gotchas Developers Run Into

• JavaScript's shifting official type. text/javascript is now the recommended MIME type per current web standards, though the older application/javascript still works in essentially every browser for backward compatibility.
• Office document types are long and easy to typo. Modern Office formats like .docx and .xlsx use verbose, vendor-specific MIME strings (built on the Office Open XML standard) that are simple to mistype by hand — copy them exactly rather than retyping them.
• SVG needs the +xml suffix. The correct type is image/svg+xml, not just image/svg or generic text/xml, and getting this wrong can prevent an SVG from rendering inline in some contexts.
• Fonts have their own top-level type now. Modern woff/woff2/ttf/otf files use the font/ type (like font/woff2) rather than the older application/font-woff convention still seen in legacy server configs.
• Generic fallback types exist for a reason. application/octet-stream is the correct fallback for "unknown binary data" — using it for a known format just means you're skipping a chance to give the client useful information about how to handle the file.

Common Mistakes to Avoid

• Trusting the file extension alone. Extensions are a convention, not a guarantee — always validate and set MIME types explicitly on the server, since a renamed file can carry a misleading extension.
• Forgetting the charset on text responses. Always pair text-based MIME types with an explicit charset=utf-8 parameter to avoid encoding-related rendering bugs.
• Using application/octet-stream for known formats. This forces the browser to guess or simply download the file, when a specific type could enable inline preview or correct handling.
• Mismatching upload validation with real-world browser behavior. Different browsers and operating systems can report slightly different MIME types for the same file extension — validate extensions as a secondary check alongside MIME type.
• Copy-pasting a similar but wrong subtype. Office and XML-based formats especially have long, easily confused subtype strings — verify against a reliable reference like this one rather than relying on memory.

Related Free Tools From Arb Digital

Pair this MIME type lookup with our HTTP Status Code Lookup when debugging response headers, or the ASCII Table and Base64 Encoder/Decoder when working with raw file data and text encoding. Investigating traffic from a specific browser or device? Try the User-Agent Parser. You'll find every free utility we've built in the free online tools hub.

Frequently Asked Questions

This MIME type lookup runs entirely in your browser — no data is sent to any server, and no signup is required.