MIME Type Lookup

Your Express server returns a .wasm file but the browser rejects it — “Refused to compile or instantiate WebAssembly module because neither ‘Content-Type’ header nor MIME type is ‘application/wasm’.” You need to know that .wasm → application/wasm, .avif → image/avif, and .mjs → text/javascript. A quick lookup is faster than Googling each one.

Why This Reference (Not the HTTP Header Parser)

The HTTP Header Parser analyzes Content-Type and other headers from an HTTP response. This tool is a MIME type lookup reference — search by file extension (.webp) or by MIME type string (application/json) across 110+ common types organized by category. Use this reference to find the right MIME type; use the header parser to analyze response headers.

What Is a MIME Type?

A MIME type (Multipurpose Internet Mail Extensions type), also called a media type or content type, is a standardized label that identifies the format of a file or data stream. Every HTTP response, email attachment, and web API payload carries a Content-Type header with a MIME type that tells the receiver how to interpret the bytes it is receiving.

The format is always type/subtype, optionally followed by parameters:

Content-Type: application/json
Content-Type: text/html; charset=utf-8
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

How to Use This Tool

Type a file extension (e.g., .jpg, png, mp4) to find its MIME type, or type a MIME type (e.g., application/json, image/) to find associated file extensions.

Each result shows:

• The file extension (e.g., .jpg)
• The official MIME type string (e.g., image/jpeg) with a one-click copy button
• A description of the format and its typical use

MIME Type Structure

Registered Top-Level Types

• text/ — human-readable text (HTML, CSS, JavaScript, CSV, Markdown)
• image/ — raster and vector images (JPEG, PNG, GIF, WebP, SVG)
• audio/ — audio streams (MP3, AAC, FLAC, Opus, WAV)
• video/ — video streams (MP4, WebM, OGG, AVI, MOV)
• application/ — structured data and binary formats (JSON, PDF, ZIP, WASM)
• font/ — web font formats (WOFF, WOFF2, TTF, OTF)
• multipart/ — composite content with multiple body parts

Common MIME Types by Category

Text

The text/* family covers human-readable documents. The most important are:

• text/html — served by every web page. The browser renders it as HTML.
• text/css — stylesheets. Browsers only apply stylesheets with this type.
• text/javascript — the IANA-registered MIME type for JavaScript files. Older servers still use application/javascript, but text/javascript is correct per RFC 9239.
• text/plain — raw unformatted text. Used for .txt files and plain-text API responses.
• text/csv — tabular data in comma-separated format. Triggers “download” behavior in most browsers.

Always specify charset=utf-8 for text types in HTTP responses:

Content-Type: text/html; charset=utf-8

Image

• image/jpeg — lossy compression, best for photographs. Extensions: .jpg, .jpeg.
• image/png — lossless compression with transparency. Use for UI graphics and screenshots.
• image/webp — Google’s modern format with both lossy and lossless modes, ~30% smaller than JPEG at equivalent quality.
• image/avif — AV1-based next-gen format with even better compression than WebP. Growing browser support.
• image/svg+xml — XML-based vector format. Scales to any resolution and is styleable with CSS.
• image/gif — supports simple animation, limited to 256 colors. Largely replaced by WebP animations and <video> for animated content.

Audio and Video

• audio/mpeg — MP3 audio. The most universally supported audio format.
• audio/opus — state-of-the-art codec for voice and music, used in WebRTC and Discord.
• video/mp4 — the dominant video format on the web, typically H.264 or H.265 encoded.
• video/webm — open royalty-free format. Required for HTML5 <video> in older Firefox versions.

For HTML5 <video> and <audio>, include the type attribute so browsers can skip sources they cannot decode:

<video>
  <source src="video.mp4" type="video/mp4">
  <source src="video.webm" type="video/webm">
</video>

Application

The application/* family is the most varied. Key types:

• application/json — JSON payloads. Used in virtually every REST and GraphQL API.
• application/xml — XML data. Used when XML is a machine-readable payload (not a document).
• application/pdf — Portable Document Format.
• application/octet-stream — generic binary fallback. Browsers will prompt a download for unknown binary types.
• application/wasm — WebAssembly binary modules.
• application/x-www-form-urlencoded — default encoding for HTML form data without file uploads.
• application/ld+json — JSON-LD structured data for SEO (Google Search) and semantic web.

Font

Web fonts must be served with the correct MIME type or browsers may block them (CORS-style blocking for fonts):

• font/woff2 — the recommended format for web fonts. Supported by all modern browsers. Uses Brotli compression.
• font/woff — WOFF 1.0. Wider compatibility with older browsers.
• font/ttf — TrueType font. Used as a fallback for browsers without WOFF2 support.

@font-face {
  font-family: 'MyFont';
  src: url('myfont.woff2') format('woff2'),
       url('myfont.woff') format('woff');
}

Multipart

Multipart types combine multiple body parts in a single message:

• multipart/form-data — required for HTML forms that upload files. Each field is a separate part.
• multipart/alternative — same content in different formats. Used in email to send both text/plain and text/html versions.
• multipart/byteranges — returned in HTTP 206 Partial Content responses when multiple byte ranges are requested.

Setting MIME Types in HTTP Servers

Nginx

# nginx.conf — add types or override defaults
types {
    application/wasm   wasm;
    font/woff2         woff2;
    image/avif         avif;
}

Apache

# .htaccess
AddType application/wasm .wasm
AddType font/woff2 .woff2
AddType image/avif .avif

Express (Node.js)

// express automatically sets Content-Type for known extensions
// For custom types:
res.setHeader('Content-Type', 'application/json');
res.send(JSON.stringify(data));

// Or use res.type():
res.type('application/json').send(data);

Cloudflare Workers / Pages

Cloudflare automatically sets correct MIME types for static assets in Pages deployments. For Workers, set the header manually:

return new Response(body, {
  headers: { 'Content-Type': 'application/json' },
});

MIME Types and Security

Content-Type Sniffing

Browsers historically tried to “sniff” the actual content when Content-Type was wrong or missing — a behavior that enabled MIME confusion attacks (e.g., uploading an HTML file disguised as an image that executes JavaScript). Always:

1. Serve every response with a correct Content-Type header
2. Add X-Content-Type-Options: nosniff to prevent browsers from overriding your declared type
3. For user-uploaded files, validate content on the server — do not trust the client-supplied filename extension

File Upload Validation

// ❌ Don't: trust the Content-Type from the client request
const type = req.headers['content-type']; // attacker-controlled

// ✅ Do: read the magic bytes and validate server-side
import { fileTypeFromBuffer } from 'file-type';
const type = await fileTypeFromBuffer(buffer);
if (!['image/jpeg', 'image/png', 'image/webp'].includes(type?.mime)) {
  throw new Error('Invalid file type');
}

CORS and MIME Types

Simple CORS requests are limited to text/plain, application/x-www-form-urlencoded, and multipart/form-data. Using application/json triggers a preflight OPTIONS request, which is the correct security behavior — it ensures the server explicitly allows cross-origin JSON requests.

Frequently Asked Questions

What is the difference between application/xml and text/xml? Both are valid for XML. text/xml is treated as text by clients (can be displayed directly), while application/xml signals that the XML is a machine-readable payload. The W3C and IETF recommend application/xml for API payloads (RFC 7303).

Why does my browser show a download dialog instead of displaying the file? The server is likely returning application/octet-stream or the wrong MIME type. Check the Content-Type response header with browser DevTools (Network tab). Set the correct type (e.g., text/html, image/png) and the browser will render it inline.

What MIME type should I use for JSON-LD structured data? Use application/ld+json in <script> tags. Google Search uses this for schema.org structured data:

<script type="application/ld+json">
{ "@context": "https://schema.org", "@type": "WebPage", ... }
</script>

Is application/javascript or text/javascript correct for JS files? text/javascript is the current IANA-registered standard (RFC 9239, 2022). application/javascript was the older registered type and is widely supported, but text/javascript is now preferred.

What MIME type should I use for TypeScript files? No MIME type is formally registered for TypeScript by IANA. Common conventions are application/typescript or text/typescript. Browsers do not execute TypeScript directly — always transpile to JavaScript before serving.

How do I serve .wasm files correctly? WebAssembly modules must be served as application/wasm. Incorrect MIME types will cause the WebAssembly.instantiateStreaming() API to fail with a MIME type error. This is the most common WASM deployment mistake.