---
url: https://findutils.com/guides/mime-type-finder-guide
title: "MIME Type Finder — Search File Types and Content Types by Extension"
description: "Look up MIME types by file extension or type string. 157 content types across 8 categories with descriptions. Copy MIME types and extensions instantly."
category: developer
content_type: guide
locale: en
read_time: 6
status: published
author: "codewitholgun"
published_at: 2026-02-22T12:00:00Z
updated_at: 2026-02-22T12:00:00Z
excerpt: "Search 157 MIME types by file extension or content type. Find the correct MIME type for any file format — from image/webp to application/json. Copy with one click."
tag_ids: ["mime-type", "content-type", "file-extension", "developer-tools", "http"]
tags: ["MIME Type", "Content Type", "File Extension", "Developer Tools", "HTTP"]
primary_keyword: "MIME type finder"
secondary_keywords: ["MIME type lookup", "file extension to MIME type", "content type list", "MIME types reference", "what MIME type for webp"]
tool_tag: "mime-type-finder"
related_tool: "mime-type-finder"
related_tools: ["mime-type-finder", "http-status-code-lookup", "html-entity-finder", "file-hash-calculator", "image-converter"]
---

# 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](/developers/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](/developers/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](/developers/mime-type-finder).

| MIME Type | Extension(s) | Category | Common Use |
|-----------|-------------|----------|------------|
| `text/html` | .html, .htm | Text | Web pages |
| `text/css` | .css | Text | Stylesheets |
| `text/javascript` | .js, .mjs | Text | JavaScript files |
| `application/json` | .json | Application | API responses, config files |
| `application/xml` | .xml | Application | Data exchange, RSS, sitemaps |
| `image/png` | .png | Image | Lossless images with transparency |
| `image/jpeg` | .jpg, .jpeg | Image | Photographs |
| `image/webp` | .webp | Image | Modern image format (smaller files) |
| `image/svg+xml` | .svg | Image | Vector graphics, icons |
| `image/avif` | .avif | Image | Next-gen image format |
| `application/pdf` | .pdf | Application | Documents |
| `font/woff2` | .woff2 | Font | Web fonts (best compression) |
| `font/woff` | .woff | Font | Web fonts (wide support) |
| `video/mp4` | .mp4 | Video | Video files |
| `audio/mpeg` | .mp3 | Audio | Audio files |
| `application/zip` | .zip | Application | Archives |
| `application/octet-stream` | (binary) | Application | Generic binary data / downloads |
| `multipart/form-data` | -- | Multipart | File uploads via HTML forms |

### 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:

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

Or add individual types in a server block:

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

### Apache

In `.htaccess` or `httpd.conf`:

```apache
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:

```javascript
const mime = require('mime-types');
mime.lookup('photo.webp');  // 'image/webp'
mime.extension('application/pdf');  // 'pdf'
```

For Express, set the Content-Type header explicitly:

```javascript
res.setHeader('Content-Type', '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](/developers/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

| Feature | FindUtils (Free) | developer.mozilla.org | freeformatter.com | sitepoint.com |
|---------|------------------|-----------------------|-------------------|---------------|
| Searchable database | Yes -- fuzzy search | No (static page) | Yes -- basic search | No (static list) |
| Number of MIME types | 157 | ~100 (common types) | ~700+ | ~200 |
| Category filtering | Yes (8 categories) | By section headings | No | By section headings |
| One-click copy (MIME type) | Yes | No | No | No |
| One-click copy (extensions) | Yes | No | No | No |
| Descriptions per entry | Yes | Yes (detailed) | Minimal | Minimal |
| File extension search | Yes | Manual scan | Yes | Manual scan |
| Dark mode | Yes | Yes | No | No |
| No ads | Yes | Yes | No (heavy ads) | No (ads present) |
| Offline-capable (client-side) | Yes | No | No | No |
| Mobile-friendly | Yes | Yes | Limited | Limited |
| Privacy (no server calls) | Yes | N/A (reference docs) | Unclear | N/A (reference docs) |

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](/developers/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

**Q: 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`.

**Q: 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](/developers/mime-type-finder) to confirm.

**Q: 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](/developers/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.

**Q: 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`.

**Q: 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.

**Q: 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.

**Q: 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](/developers/mime-type-finder) -- Search 157 MIME types by extension or type string with one-click copy
- [HTTP Status Code Lookup](/developers/http-status-code-lookup) -- Look up HTTP response codes when debugging Content-Type and server issues
- [HTML Entity Finder](/developers/html-entity-finder) -- Search HTML entities for special characters in web content
- [File Hash Calculator](/security/file-hash-calculator) -- Calculate file checksums when verifying downloaded content integrity
- [Image Converter](/convert/image-converter) -- Convert between image formats like PNG, WebP, and AVIF that require different MIME types