MIME Type Finder — Search File Types and Content Types by Extension

Every file served over HTTP needs a Content-Type header that tells the browser how to handle it. Get the MIME type wrong and images download instead of displaying, JSON responses render as plain text, and fonts fail to load with a CORS error. The FindUtils MIME Type Finder lets you search 157 MIME types across 8 categories by file extension or type string, copy the result with one click, and move on -- no memorization, no digging through RFC documents.

This guide covers what MIME types are, how to use the tool, which MIME types matter most for web development, and how to configure them on your server.

What Is a MIME Type

MIME stands for Multipurpose Internet Mail Extensions. Originally designed for email attachments in the early 1990s, the standard was adopted by HTTP to identify content types in web responses. A MIME type is a two-part string in the format type/subtype:

• type -- The general category: application, audio, font, image, text, video, multipart, or message
• subtype -- The specific format: json, png, mp4, pdf, html, etc.

For example, image/png tells the browser the response body is a PNG image. application/json signals a JSON payload. text/html indicates an HTML document.

Where MIME Types Appear

MIME types show up in several critical places across web infrastructure:

• HTTP Content-Type header -- Content-Type: application/json; charset=utf-8
• HTML <script> and <link> tags -- <script type="module">, <link type="text/css">
• File upload validation -- Checking file.type in JavaScript before uploading
• Web server configuration -- Nginx mime.types, Apache AddType directives
• API responses -- Setting the correct Content-Type so clients parse responses properly
• Email attachments -- The original use case, still relevant for SMTP

Getting the MIME type wrong is a silent failure mode. The server returns a 200 OK, but the content is misinterpreted. Debugging this without a reference tool means searching Stack Overflow or reading RFC 6838. The FindUtils MIME Type Finder cuts that lookup to seconds.

How to Use the MIME Type Finder

Step 1: Open the Tool

Navigate to the MIME Type Finder on findutils.com. The interface shows a search bar, a category filter dropdown, and a list of all 157 MIME types with their extensions, descriptions, and category badges. No account or signup required.

Step 2: Search by Extension or Type

Type any file extension or MIME type string into the search field. The tool uses fuzzy search, so partial matches work. Examples:

• Type pdf to find application/pdf
• Type webp to find image/webp
• Type json to find application/json
• Type woff to find font/woff and font/woff2
• Type video to see all video MIME types

Results update in real time as you type. Each result shows the full MIME type, its category badge (color-coded), a human-readable description, and all associated file extensions.

Step 3: Filter by Category

Use the category dropdown to narrow results to one of the 8 MIME categories: Application, Audio, Font, Image, Text, Video, Multipart, or Message. This is useful when you know the general type but not the specific subtype -- for example, browsing all Image types to find the right one for your use case.

Step 4: Copy the MIME Type or Extension

Each result row has two copy buttons:

• Copy Type -- Copies the full MIME type string (e.g., application/json) to your clipboard
• Copy Extension -- Copies the associated file extensions (e.g., .json)

A checkmark icon confirms the copy succeeded. Paste the value directly into your server configuration, API response header, or code.

Step 5: Clear and Search Again

Click the clear button next to the search field to reset your query and browse the full list. The tool is stateless -- no data is stored or transmitted. All processing happens in your browser.

Essential MIME Types for Web Developers

The following table covers the MIME types web developers use most frequently. All of these are searchable in the MIME Type Finder.

MIME Types That Cause Trouble

Some MIME types are frequently misconfigured, leading to bugs that are hard to trace:

text/javascript vs application/javascript -- RFC 9239 (2022) officially deprecated application/javascript in favor of text/javascript. Most servers still accept both, but text/javascript is the correct one to use going forward.

image/svg+xml not image/svg -- SVG files must be served as image/svg+xml. Using image/svg (without the +xml) causes browsers to treat the file as an unknown format.

application/octet-stream as a fallback -- When a server does not recognize a file extension, it often defaults to application/octet-stream, which forces the browser to download the file instead of rendering it. If users report that files are downloading instead of opening, check the MIME type configuration.

font/woff2 not application/font-woff2 -- The font/ top-level type was registered in 2017. Older configurations using application/font-woff2 still work in most browsers but are technically incorrect. Use font/woff2 for compliance.

Configuring MIME Types on Your Server

Nginx

Nginx loads MIME types from /etc/nginx/mime.types. To add or override a type:

types {
    application/json  json;
    image/webp        webp;
    image/avif        avif;
    font/woff2        woff2;
}

Or add individual types in a server block:

location ~* \.webp$ {
    types { }
    default_type image/webp;
}

Apache

In .htaccess or httpd.conf:

AddType image/webp .webp
AddType image/avif .avif
AddType font/woff2 .woff2
AddType application/json .json

Node.js / Express

The mime-types npm package handles lookups programmatically:

300">"text-purple-300">const mime = require(300">'mime-types');
mime.lookup(300">'photo.webp');  // 300">'image/webp'
mime.extension(300">'application/pdf');  // 300">'pdf'

For Express, set the Content-Type header explicitly:

res.setHeader(300">'Content-Type', 300">'application/json; charset=utf-8');
res.send(JSON.stringify(data));

Vercel / Netlify / Cloudflare Pages

Static hosting platforms handle MIME types automatically for known extensions. For uncommon file types, add a _headers file or configure the platform's response headers to set the correct Content-Type.

MIME Types and Security

MIME types intersect with browser security in ways that catch developers off guard.

MIME Sniffing and X-Content-Type-Options

Browsers historically performed "MIME sniffing" -- guessing the content type from the file contents rather than trusting the Content-Type header. This created security vulnerabilities where a file served as text/plain could be executed as JavaScript. The X-Content-Type-Options: nosniff header disables this behavior, forcing the browser to respect the declared MIME type. Always set this header in production.

File Upload Validation

When validating file uploads, never rely solely on the file extension. Check the type property of the File object (which reflects the MIME type) and, for critical applications, inspect the file's magic bytes on the server side. The MIME Type Finder helps you identify the correct MIME type to validate against.

Content Security Policy

CSP directives like script-src and style-src interact with MIME types. A script served with the wrong MIME type (e.g., text/plain instead of text/javascript) will be blocked by CSP even if the source is whitelisted.

FindUtils MIME Type Finder vs Alternatives

MDN Web Docs remains the gold standard for detailed explanations of individual MIME types and their history. But when you need to quickly look up "what is the MIME type for .woff2" and copy it into your config, FindUtils is faster -- type the extension, get the answer, copy, done. No scrolling through a documentation page.

Common MIME Type Mistakes

Serving CSS as text/plain. If stylesheets are not applying and the browser console shows "MIME type mismatch," the server is returning the CSS file with the wrong Content-Type. Verify your server maps .css to text/css.

Using application/x-javascript. The x- prefix was an experimental convention that was never standardized. Use text/javascript instead.

Forgetting charset on text types. For text/html, text/css, and application/json, include the charset parameter: Content-Type: text/html; charset=utf-8. Without it, browsers may use a default encoding that corrupts non-ASCII characters.

Serving WebP as image/png. If you convert images to WebP but forget to update the MIME type mapping, browsers receive WebP data labeled as PNG and fail to decode it. Use the MIME Type Finder to confirm the correct type for newer formats.

Confusing multipart/form-data with application/x-www-form-urlencoded. HTML forms use application/x-www-form-urlencoded by default. Switch to multipart/form-data only when the form includes file uploads. Using the wrong encoding causes file data to be corrupted or missing on the server side.

FAQ

Q1: What is the correct MIME type for JSON? A: The correct MIME type is application/json, as defined in RFC 8259. While text/json appears in some older code, it was never standardized and should not be used. APIs should always return Content-Type: application/json; charset=utf-8.

Q2: What MIME type should I use for WebP images? A: Use image/webp. If your server does not recognize WebP files, add the mapping manually. In Nginx: types { image/webp webp; }. In Apache: AddType image/webp .webp. Look up any format in the MIME Type Finder to confirm.

Q3: How do I find the MIME type for a file extension I have never seen before? A: Type the extension into the FindUtils MIME Type Finder search bar. The fuzzy search matches partial strings, so even typing avif or wasm will return the correct MIME type instantly. If the extension is not in the database, application/octet-stream is the standard fallback.

Q4: What is the difference between type and subtype in a MIME type? A: The type is the broad category (image, text, application, audio, video, font, multipart, message) and the subtype identifies the specific format (png, html, json, mp4). Together they form the full MIME type: image/png, text/html, application/json.

Q5: Why does my browser download a file instead of displaying it? A: The server is likely returning application/octet-stream or a missing Content-Type header. Browsers treat unknown content types as downloads. Fix this by configuring the correct MIME type on your server. Use the MIME Type Finder to look up the right value for the file extension.

Q6: Is my data safe when using this tool? A: Yes. The MIME Type Finder runs entirely in your browser using client-side JavaScript. No search queries, file names, or any other data are sent to a server. The full database of 157 MIME types is loaded with the page. You can even use it offline once the page is cached.

Q7: Should I use font/woff2 or application/font-woff2? A: Use font/woff2. The font/ top-level type was officially registered with IANA in 2017 (RFC 8081). The older application/font-woff2 is still recognized by browsers for backward compatibility, but font/woff2 is the correct standard. The same applies to font/woff, font/ttf, and font/otf.

Tools Used

• MIME Type Finder -- Search 157 MIME types by extension or type string with one-click copy
• HTTP Status Code Lookup -- Look up HTTP response codes when debugging Content-Type and server issues
• HTML Entity Finder -- Search HTML entities for special characters in web content
• File Hash Calculator -- Calculate file checksums when verifying downloaded content integrity
• Image Converter -- Convert between image formats like PNG, WebP, and AVIF that require different MIME types