MIME Type Lookup

Search IANA MIME types and file extensions with HTTP Content-Type headers, or drop files to verify magic-byte signatures locally in your browser.

No uploadsNo sign-upBatch processing
120+ IANA Media TypesLocal File & Magic-Byte Check1-Click Content-Type Copy
Lookup MIME Types
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free MIME Type Lookup?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

Full IANA Media Type Directory

Indexes standard application, text, image, audio, video, font, and multipart MIME types per RFC 6838 and RFC 2046, including structured syntax suffixes like +json, +xml, and +zip.

Magic-Byte vs. Extension Inspector

Reads leading hexadecimal file signatures (such as 89 50 4E 47 for PNG or 25 50 44 46 for PDF) locally to detect misnamed assets or spoofed upload extensions.

HTTP Header & Compression Notes

Provides copy-ready Content-Type header snippets, explicit charset=utf-8 rules, and Brotli or Gzip compressibility guidance for Nginx, CDN, and object storage buckets.

Zero-Upload Binary Slicing

Reads only the leading header bytes of dropped files in browser memory via Blob.slice() and Uint8Array, inspecting multi-gigabyte archives instantaneously with zero network transfers.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
Bidirectional Search (Extension ↔ MIME) Instant lookup by file extension (.webp, .wasm) or full Content-Type header Ctrl+F on a raw IANA text dump with thousands of obscure vendor entries
File Magic Byte (Signature) Verification Drop any local file to inspect its actual magic header bytes vs its extension Trusts the filename string only and cannot detect misnamed binary files
Server Config & Header Snippets Provides ready-to-copy NGINX types, Apache AddType, and HTTP Content-Type Lists the MIME string only without web server configuration syntax
Modern Web & Media Format Coverage Includes AVIF, WebP, WebAssembly, ES Modules (.mjs), Fonts (.woff2) & 3D assets Legacy tables missing modern browser media and developer asset types
How it works

How to Use MIME Type Lookup in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Search Extension or Media Type

Query a file extension such as .webp, .wasm, or .mjs, or enter a MIME string such as application/problem+json to view its canonical IANA record.

2

Drop a File to Verify Magic Bytes

Drag a local file onto the dropzone to compare its actual hexadecimal header signature against the media type implied by its filename extension.

3

Copy Content-Type & Security Headers

Copy the exact Content-Type header snippet along with charset parameters, CDN compression recommendations, and X-Content-Type-Options: nosniff protection.

Inspecting File Extensions and Magic-Byte Signatures in Practice

Quick Answer: Search any file extension or drop a local file into the inspector to compare its filename-mapped MIME type against its binary magic-byte header, catching misnamed assets before they break strict browser nosniff checks.

Relying solely on filename extensions when serving static assets or validating user uploads frequently causes production bugs. Content pipelines routinely save WebP or AVIF images with a legacy .jpg extension, and misconfigured S3 uploads often fall back to application/octet-stream or text/plain.

When you drop a local file named product-hero.jpg onto the inspector, the tool slices the opening bytes in memory and compares the binary signature against the extension mapping:

Filename:          product-hero.jpg
Header Hex (0x00): 52 49 46 46 24 A1 01 00 57 45 42 50 56 50 38 58
Header ASCII:      R  I  F  F  $  .  .  .  W  E  B  P  V  P  8  X

Instead of the JPEG Start-of-Image marker (FF D8 FF), bytes 0x00–0x03 contain RIFF and bytes 0x08–0x0B contain WEBP. The inspector flags the mismatch immediately and generates the accurate HTTP metadata:

{
  "fileName": "product-hero.jpg",
  "claimedExtension": ".jpg",
  "claimedMimeType": "image/jpeg",
  "detectedMagicHex": "52 49 46 46 ?? ?? ?? ?? 57 45 42 50",
  "detectedMimeType": "image/webp",
  "extensionMismatch": true,
  "charsetRequired": false,
  "compressible": false,
  "recommendedHeaders": [
    "Content-Type: image/webp",
    "X-Content-Type-Options: nosniff"
  ]
}

For text-based assets without binary magic signatures—such as ES modules (.mjs or .js)—searching the directory outputs the exact RFC 9239 compliant header block ready for Nginx, Cloudflare Workers, or S3 metadata:

Content-Type: text/javascript; charset=utf-8
X-Content-Type-Options: nosniff

RFC 6838 Media Type Syntax, Structured Suffixes, Charset Rules, and MIME Sniffing Security

Quick Answer: IANA Media Types follow the type/subtype grammar defined in RFC 2045 and RFC 6838, governed by registration trees, structured syntax suffixes like +json and +xml, strict UTF-8 charset rules, and WHATWG MIME Sniffing security boundaries.

An HTTP Content-Type header carries a media type essence (type/subtype) optionally followed by semicolon-delimited parameters (type/subtype; parameter=value). Both the top-level type and subtype are case-insensitive ASCII tokens normalized to lowercase by convention.

Top-Level Registries, Trees, and Structured Suffixes

RFC 2046, RFC 6838, and RFC 8081 partition media types across discrete registries:

  • Discrete and Composite Top-Level Types: application, text, image, audio, video, and font (standardized in RFC 8081 to replace legacy application/font-woff with font/woff and font/woff2), plus composite types multipart (such as multipart/form-data requiring a mandatory boundary parameter) and message.
  • Registration Trees: Standards-tree types carry no prefix (application/pdf), vendor-tree types use vnd. (application/vnd.ms-excel), and personal-tree types use prs.. Unregistered x- prefixes (such as application/x-tar) were deprecated by RFC 6648 in favor of direct standards registration, though legacy tokens remain common.
  • Structured Syntax Suffixes (RFC 6838 / RFC 6839): Appending +json, +xml, +zip, +cbor, or +gzip declares the underlying serialization format—for example, application/problem+json (RFC 9457 HTTP Problem Details), application/ld+json, or image/svg+xml—allowing API gateways and CDN compression filters to parse or compress payloads without hardcoding every vendor subtype.

Charset Parameter Nuances

Adding charset=utf-8 indiscriminately across all MIME types violates specification boundaries:

  • text/* Subtypes: Always specify charset=utf-8 on text/html, text/plain, text/css, text/csv, and text/javascript so browsers and HTTP clients never fall back to legacy ISO-8859-1 or Windows-1252 decoding.
  • application/json: RFC 8259 Section 8.1 mandates UTF-8 encoding for interoperable JSON and explicitly registers application/json with no charset parameter. While tolerant receivers ignore application/json; charset=utf-8, strict RFC-compliant emitters output Content-Type: application/json.
  • Binary Types: Never attach a charset parameter to image/*, audio/*, video/*, font/*, application/wasm, or application/octet-stream.

Container Offsets and MIME Sniffing Security

Binary magic-byte detection must account for non-zero offsets and shared container envelopes. TAR archives store ustar (75 73 74 61 72) at byte offset 0x101 (257). ISO Base Media File Format containers store an ftyp box starting at offset 0x04, where the major brand bytes distinguish image/avif (avif), image/heic (heic), and video/mp4 (isom or mp42). Similarly, .docx, .xlsx, .epub, and .jar files all begin with the PKZIP local file header 50 4B 03 04.

Because legacy browsers historically ran heuristic sniffing (standardized in the WHATWG MIME Sniffing specification) over the first 512 to 1445 bytes whenever a server returned text/plain or omitted Content-Type, attackers could upload polyglot files containing embedded HTML or JavaScript to trigger stored XSS. Emitting an accurate Content-Type paired with X-Content-Type-Options: nosniff disables content sniffing and enforces strict MIME validation on <script> and <link rel="stylesheet"> subresources.

MIME Type Lookup vs HTTP Status Codes Reference: Which One Do You Need?

Quick Answer: Use MIME Type Lookup to resolve IANA Content-Type headers, extension mappings, and binary magic-byte signatures, and use HTTP Status Codes Reference to interpret 1xx-5xx response semantics, content-negotiation rejections, and access-log error rates.

In HTTP APIs and static asset pipelines, media type headers and response status codes work together during content negotiation and payload validation.

Capability MIME Type Lookup HTTP Status Codes Reference
HTTP Message Surface Entity representation headers (Content-Type, Accept) Response status line & :status pseudo-header (1xx–5xx)
Primary Specifications RFC 6838, RFC 2046, RFC 8081, RFC 9239, WHATWG Sniffing RFC 9110, RFC 6585, RFC 7725, RFC 8297
Local Browser Inspector Binary file magic-byte vs. extension inspector Pasted HTTP access-log status extractor & counter
Compression & Caching Focus Brotli/Gzip compressibility & charset=utf-8 rules Heuristic cacheability, redirect methods & Retry-After
Typical Debugging Target Blocked ES modules, nosniff errors, spoofed uploads 406/415 rejections, 307/308 redirects, 502/504 spikes

How Both Tools Pair Together

When a client sends an Accept header that the server cannot satisfy, or uploads a payload whose Content-Type header violates endpoint constraints, the server responds with 406 Not Acceptable or 415 Unsupported Media Type. Use MIME Type Lookup to verify the exact IANA media string and magic-byte signature of your payload, and cross-reference HTTP Status Codes Reference to inspect the RFC 9110 response requirements, companion headers, and access-log error distributions.

FAQ

MIME Type Lookup FAQ and Technical Guide

Everything you need to know about using Utiliome's free online mime type lookup.

Should JavaScript files use text/javascript or application/javascript?

Use text/javascript. RFC 9239 formally obsoleted application/javascript, application/ecmascript, and text/ecmascript across the IANA registry to align with the HTML Living Standard and browser ES module loaders.

Does application/json require a charset=utf-8 parameter in the Content-Type header?

No. RFC 8259 specifies that JSON exchanged between systems must be encoded in UTF-8 without a byte-order mark and defines no charset parameter for application/json. By contrast, text/* media types such as text/html, text/plain, and text/csv should include charset=utf-8 explicitly.

Why does X-Content-Type-Options: nosniff block my script or stylesheet in the browser?

When X-Content-Type-Options: nosniff is present on a response, browsers enforce strict MIME essence matching: scripts execute only if Content-Type is a valid JavaScript MIME type (such as text/javascript), and stylesheets apply only if Content-Type is text/css. If a misconfigured object bucket or proxy serves a .js or .css bundle as text/plain or application/octet-stream, the browser aborts loading it.

Why do DOCX, XLSX, EPUB, and JAR files show PKZIP magic bytes during binary inspection?

Office Open XML (.docx, .xlsx, .pptx), EPUB e-books, Java JARs, and Android APKs are all packaged inside standard ZIP archive containers beginning with hexadecimal bytes 50 4B 03 04. Distinguishing them beyond leading magic bytes requires inspecting internal archive filenames, such as [Content_Types].xml for Office documents or the uncompressed mimetype entry inside EPUB archives.

Which MIME types should be compressed with Brotli or Gzip on a web server or CDN?

Enable Brotli or Gzip on text and structured formats with high redundancy, including text/html, text/css, text/javascript, application/json, application/problem+json, application/xml, image/svg+xml, application/wasm, and font/ttf. Disable HTTP compression on pre-compressed binary formats such as image/webp, image/avif, image/jpeg, image/png, font/woff2, audio/mpeg, and video/mp4 to avoid wasting CPU cycles without shrinking transfer size.