A MIME type is a two-part identifier like `image/jpeg` that tells HTTP servers, browsers, and email clients what format a byte stream carries. The format comes from [RFC 2045/2046](https://www.rfc-editor.org/rfc/rfc2045) and consists of a top-level type (application, audio, font, image, message, model, multipart, text, video) plus a subtype. Servers send the MIME in the [`Content-Type` header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types), browsers use the value to decide whether to display inline, hand off to a plugin, or offer a download. More background: the [IANA Media Types Registry](https://www.iana.org/assignments/media-types/media-types.xhtml) — the official list with hundreds of entries.

How do I detect a file's MIME type without an extension?

The first bytes of a file (its "magic number" or file signature) reveal the format. A JPEG starts with `FF D8 FF`, a PNG with `89 50 4E 47 0D 0A 1A 0A`, a PDF with `25 50 44 46` (ASCII for "%PDF"), a WebAssembly module with `00 61 73 6D`. The tool reads the first 32 bytes locally in the browser and matches them against a signature table. Container formats like HEIC, AVIF, and MP4 use [ISO Base Media boxes](https://en.wikipedia.org/wiki/ISO/IEC_base_media_file_format) — the type lives in the `ftyp` block at byte 4. Wikipedia maintains a complete [list of file signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) covering every common pattern.

What's the difference between application/vnd.rar and application/x-rar-compressed?

`application/vnd.rar` is IANA-registered since 2014; `application/x-rar-compressed` is deprecated. The `vnd.` prefix marks vendor-specific subtypes that have been formally registered — per [RFC 6838](https://www.rfc-editor.org/rfc/rfc6838#section-3.2). The `x-` prefix was historically meant for experimental codes but was declared an anti-pattern in 2012 by [RFC 6648](https://www.rfc-editor.org/rfc/rfc6648). In practice most browsers and servers accept both variants, but the tool filter `IANA-registered only` hides the `x-` aliases so new server configs use the modern codes. Analogous: `image/x-icon` (legacy) vs `image/vnd.microsoft.icon` (IANA since 2003).

Which MIME type applies to JavaScript modules?

`text/javascript` is the canonical recommendation since 2022 — `application/javascript` was the long-time standard before. The [WHATWG HTML Spec](https://html.spec.whatwg.org/multipage/scripting.html#scriptingLanguages) is now clear: `text/javascript` is the only officially supported variant for ` ` tags. IANA reclassified the code accordingly in 2022. For ES modules (`.mjs`) and CommonJS modules (`.cjs`) the same MIME applies. Browsers still tolerate `application/javascript` for compatibility, but new server configs should emit `text/javascript`. The tool shows both codes in the filter with a note on which one is current.

Which MIME type does WebAssembly require?

`application/wasm` is mandatory — otherwise `WebAssembly.instantiateStreaming()` will reject the file. That method is the only streaming variant in the WebAssembly JS API and checks the `Content-Type` header strictly. If your server delivers `.wasm` files as `application/octet-stream` or `text/html` (a common default!), you fall back to the slower `WebAssembly.instantiate(arrayBuffer)` path. Fix: add `application/wasm wasm;` to your Apache `mime.types` or nginx `types { }` block. The tool's export feature generates the correct line per server stack — copy and paste into the config.

How do I tell HEIC, AVIF, and JXL apart?

All three are modern image containers, but their browser support differs in 2026. AVIF (`image/avif`, extension `.avif`) is based on the AV1 video codec and ships in Chrome 85+, Firefox 93+, and Safari 16+ — the broadest support. HEIC (`image/heic`, extension `.heic`) is Apple's default capture format since iOS 11, based on HEVC, and currently only Safari 17+ displays it natively. JXL (`image/jxl`, extension `.jxl`) is the newest codec, royalty-free, available in Firefox 111+ and Safari 17+ (Chrome removed it in 2023). The magic bytes distinguish all three: AVIF and HEIC start with the `ftyp` box marker at byte 4 plus a brand string `avif` or `heic`, while JXL has its own `FF 0A` or `JXL ` signature block.

Which Content-Type does a web app manifest need?

`application/manifest+json` is required — otherwise the browser will not show the PWA install banner. The [Web App Manifest](https://developer.mozilla.org/en-US/docs/Web/Manifest) is a JSON document that describes `name`, `icons`, `start_url`, and `display`. Browsers load it via ` ` and check the `Content-Type`. If it ships as `application/json` or `text/html`, the browser silently ignores it — no install banner, no PWA behaviour. Fix in nginx: add `application/manifest+json webmanifest;` to the `types { }` block. In Apache: `AddType application/manifest+json .webmanifest`. The tool's export does this automatically.

Does this tool see my file?

No. The MIME database is embedded in the browser bundle — no API, no backend. On file drop the tool reads the first 32 bytes via the [FileReader API](https://developer.mozilla.org/en-US/docs/Web/API/FileReader) locally in the browser. You can verify: open F12, the "Network" tab, drop a file into the zone — only page-load requests appear, no additional traffic. Bytes never leave your browser. Search, category filters, and config export also run pure-client. No cookie is set, no `localStorage` entry persists.

DEV TOOL

MIME type finder — magic bytes + server config export

Bidirectional lookup, in-browser magic-byte detection, and snippet export for five server stacks — all local, no file upload.

Runs locally in the browser — the database is embedded, file bytes never upload.

100 MIME types · 81 IANA-registered · 15 modern

Magic-byte detection

Drop a file here — we read the first 32 bytes locally and detect the true MIME type. or click to pick

Filters

IANA-registered only Modern formats only (2018+)

Results

100 of 100

Export server config

Generated from the current filter selection — refine filters, then copy or download the config.

# nginx types — generated by kittokit mime-type-finder
# Drop this block into your http {} or server {} context.
types {
    application/atom+xml    atom;
    application/epub+zip    epub;
    application/gzip    gz;
    application/java-archive    jar;
    application/javascript    js mjs;
    application/json    json;
    application/ld+json    jsonld;
    application/manifest+json    webmanifest;
    application/msword    doc;
    application/octet-stream    bin;
    application/pdf    pdf;
    application/postscript    ps eps;
    application/rss+xml    rss;
    application/rtf    rtf;
    application/sql    sql;
    application/vnd.android.package-archive    apk;
    application/vnd.apple.installer+xml    mpkg;
    application/vnd.microsoft.portable-executable    exe dll;
    application/vnd.ms-excel    xls;
    application/vnd.ms-powerpoint    ppt;
    application/vnd.oasis.opendocument.presentation    odp;
    application/vnd.oasis.opendocument.spreadsheet    ods;
    application/vnd.oasis.opendocument.text    odt;
    application/vnd.openxmlformats-officedocument.presentationml.presentation    pptx;
    application/vnd.openxmlformats-officedocument.spreadsheetml.sheet    xlsx;
    application/vnd.openxmlformats-officedocument.wordprocessingml.document    docx;
    application/vnd.rar    rar;
    application/wasm    wasm;
    application/x-7z-compressed    7z;
    application/x-bzip2    bz2;
    application/x-debian-package    deb;
    application/x-iso9660-image    iso;
    application/x-msdownload    exe dll;
    application/x-msi    msi;
    application/x-rar-compressed    rar;
    application/x-rpm    rpm;
    application/x-shockwave-flash    swf;
    application/x-tar    tar;
    # application/x-www-form-urlencoded (no extensions defined)
    application/x-xz    xz;
    application/xhtml+xml    xhtml xht;
    application/xml    xml;
    application/yaml    yaml yml;
    application/zip    zip;
    application/zstd    zst;
    audio/aac    aac;
    audio/flac    flac;
    audio/midi    mid midi;
    audio/mp4    m4a;
    audio/mpeg    mp3;
    audio/ogg    ogg oga;
    audio/opus    opus;
    audio/wav    wav;
    audio/webm    weba;
    font/collection    ttc;
    font/otf    otf;
    font/ttf    ttf;
    font/woff    woff;
    font/woff2    woff2;
    image/apng    apng;
    image/avif    avif;
    image/bmp    bmp;
    image/gif    gif;
    image/heic    heic heif;
    image/heic-sequence    heics;
    image/jpeg    jpg jpeg jpe jfif;
    image/jxl    jxl;
    image/png    png;
    image/svg+xml    svg svgz;
    image/tiff    tif tiff;
    image/vnd.adobe.photoshop    psd;
    image/vnd.microsoft.icon    ico;
    image/webp    webp;
    image/x-icon    ico;
    image/x-portable-pixmap    ppm;
    model/gltf-binary    glb;
    model/gltf+json    gltf;
    model/obj    obj;
    model/stl    stl;
    text/calendar    ics;
    text/css    css;
    text/csv    csv;
    # text/event-stream (no extensions defined)
    text/html    html htm;
    text/javascript    js mjs cjs;
    text/markdown    md markdown;
    text/plain    txt;
    text/tab-separated-values    tsv;
    text/vcard    vcf;
    text/xml    xml;
    text/yaml    yaml yml;
    video/3gpp    3gp;
    video/av1    av1;
    video/mp4    mp4 m4v;
    video/mpeg    mpeg mpg;
    video/ogg    ogv;
    video/quicktime    mov qt;
    video/webm    webm;
    video/x-matroska    mkv;
    video/x-msvideo    avi;
}

How It Works

01

Paste text or code

Paste your content into the input field or type directly.
02

Instant processing

The tool processes your content immediately and shows the result.
03

Copy result

Copy the result to your clipboard with one click.

Privacy

All calculations run directly in your browser. No data is sent to any server.

Finding the right MIME type is harder than it should be in 2026: hundreds of IANA codes, deprecated `x-` aliases, modern formats missing from older cheatsheets, and the `Content-Type` header cannot be inferred from filename alone. The finder solves it in one tool — search by extension or MIME, drop a file for magic-byte detection, and export configs for five server stacks.

01 — How to Use

How do you use this tool?

Use the search field — enter an extension (`.webp`), a MIME (`image/webp`), or a keyword.
Drag a file onto the drop zone — the first 32 bytes are read locally and matched against the magic-byte table.
If filename and bytes disagree, a mismatch warning appears — bytes are authoritative.
Category pills filter by application/image/audio/video/font/model/text. IANA and modern toggles narrow further.
Copy the server config for your stack — Apache `mime.types`, nginx `types { }`, IIS `web.config`, Express middleware, or Cloudflare Worker.

What does the MIME type finder do?

The finder is a bidirectional lookup tool plus magic-byte detector for MIME types. You search for a file extension (.webp, .heic, .wasm) and get the canonical MIME plus alias list, or you enter a MIME (image/webp, application/wasm) and see the associated extensions with a “canonical first” marker. Both directions live in one search field because the most common question is one of those two: “what Content-Type for .webp?” or “which extension comes out of audio/ogg?”.

Per entry the tool shows: IANA status (registered or deprecated alias), canonical and alternate extensions, a one-sentence format description, optional browser support for modern codecs (AVIF, HEIC, JXL, WOFF2, WebAssembly), and the magic-byte signature used for detection.

How does magic-byte detection work?

Drag a file onto the drop zone — the first 32 to 64 bytes are read locally via FileReader and matched against the signature table. JPEG identifies itself with FF D8 FF at byte 0, PNG with 89 50 4E 47 0D 0A 1A 0A, PDF with 25 50 44 46 (ASCII “%PDF”), WebAssembly with 00 61 73 6D. Container formats like HEIC, AVIF, and MP4 use ISO Base Media boxes with the ftyp marker at byte 4 — the brand string after it (heic, avif, isom, mp42) decides which concrete variant is present.

The drop is authoritative: if the filename says .jpg but the bytes say 89 50 4E 47, a mismatch warning appears. Bytes never lie — a file can be renamed at any time. This is the only reliable way to check a MIME type for upload validation when the User-Agent headers are not trustworthy.

What’s the difference between IANA-registered and `x-` aliases?

IANA-registered MIME types live in the official Media Types Registry and are formally standardised via RFC 6838. The vnd. prefix marks vendor-specific codes (e.g. application/vnd.ms-excel for .xls) that map to a specific vendor. The x- prefix used to mean “experimental” but was declared an anti-pattern in 2012 by RFC 6648: new codes should be registered directly, not introduced as x-.

In practice some duplicates remain in 2026: image/x-icon (legacy, browser-tolerated) vs image/vnd.microsoft.icon (IANA-registered since 2003), or application/x-rar-compressed (deprecated) vs application/vnd.rar (IANA since 2014). The tool’s IANA-registered only toggle hides the x- aliases so new server configs use the modern codes. Existing servers should accept both — browsers historically often send the legacy prefix.

Which modern formats does the finder cover in 2026?

The database knows the important new codecs of the last few years, including browser support data sourced from Can I Use:

Image: AVIF (image/avif, AV1-based, Chrome 85+/Firefox 93+/Safari 16+), HEIC (image/heic, HEVC-based, Safari 17+), JXL (image/jxl, royalty-free, Firefox 111+/Safari 17+), WebP (image/webp, ubiquitous).
Audio: Opus (audio/opus, low-latency, RFC 6716), FLAC (audio/flac).
Video: AV1 (video/av1, royalty-free, Chrome 70+/Firefox 67+/Safari 17+), WebM container.
Font: WOFF2 (font/woff2, Brotli-compressed, the canonical web font since 2018).
Application: WebAssembly (application/wasm, mandatory for streaming compilation), Web App Manifest (application/manifest+json, mandatory for PWA install banners), JSON-LD (application/ld+json, schema.org structured data), Zstandard (application/zstd, IANA 2018).
3D model: glTF binary (model/gltf-binary, single-file 3D asset for WebGL/three.js).

The “modern formats only” toggle filters down to these 2018-2026 additions — useful when wiring up a modern static-asset server that doesn’t need to know about the older DCT/RGB/indexed formats.

Which server configs can the finder export?

Five targets, all generated from the current filter selection:

Apache mime.types — one-MIME-per-line format with space-separated extensions. Drop directly into the server config.
nginx types { } — block for http {} or server {} context with correct semicolons.
IIS web.config — <staticContent> XML with <mimeMap> elements for each extension/MIME pair.
Express/Koa middleware — JavaScript snippet with a MIME_BY_EXT map and a setHeaders function that plugs into express.static options.
Cloudflare Worker — default fetch handler that rewrites the Content-Type response header based on the URL extension — useful when the origin emits the wrong MIME.

Workflow: set category + IANA + modern filters, then pick an export tab. The tool shows the snippet live, the copy button puts it on the clipboard, the download button saves it with the server-typical filename (mime.types, web.config, mime.types.conf, .js).

Which magic-byte signatures does the finder recognise?

More than 40 format signatures, grouped by complexity:

Trivial (1-4 bytes at offset 0): JPEG (FF D8 FF), PNG (89 50 4E 47 0D 0A 1A 0A), GIF (47 49 46 38 37 61 or …39 61), PDF (25 50 44 46), ZIP/OOXML (50 4B 03 04), 7z (37 7A BC AF 27 1C), Gzip (1F 8B), bzip2 (42 5A 68), Zstandard (28 B5 2F FD).
RIFF containers (with wildcard bytes for size): WebP (RIFF????WEBP), WAV (RIFF????WAVE), AVI (RIFF????AVI ).
ISO Base Media boxes (at offset 4 after size prefix): MP4 (ftypisom, ftypMSNV, ftypmp42), HEIC (ftypheic, ftypheix, ftypmif1), AVIF (ftypavif), QuickTime (ftypqt ), 3GPP (ftyp3gp4).
WebAssembly: 00 61 73 6D plus a 4-byte version field.
Font containers: WOFF (wOFF), WOFF2 (wOF2), TrueType (00 01 00 00), OpenType (OTTO), font collection (ttcf).
Legacy Office: OLE Compound (D0 CF 11 E0 A1 B1 1A E1) for .doc/.xls/.ppt/.msi.
Archives: RAR v4 (52 61 72 21 1A 07 00), RAR v5 (52 61 72 21 1A 07 01 00), Debian (!<arch>), RPM (ED AB EE DB).

The wildcard syntax ?? lets variable bytes sit inside a signature — for RIFF containers that’s the 4-byte size field that differs per file. Same notation as in the PHP finfo magic database and the Unix file(1) tool.

How private is the byte detection?

Pure-client from start to finish. The complete MIME database is embedded in the JavaScript bundle (under 50 KB minified), search and filter logic runs on the main thread. On file drop the FileReader API reads the first 32-64 bytes into a Uint8Array in RAM — the file itself is not further touched, reading happens client-side, no bytes leave the browser. To verify: open F12, the Network tab, drop a file — no additional requests appear.

The server config export is also pure-JS: selected entries are formatted into string snippets, the copy button uses the Clipboard API, the download button creates a Blob object URL. No backend, no login, no telemetry pixel.

Last updated: 05/17/2026