Referencia de tipos MIME

Qué es un tipo MIME

Los tipos MIME (Multipurpose Internet Mail Extensions) son la forma estándar de identificar el formato y la naturaleza de un archivo. Se escriben como tipo/subtipo e indican a navegadores y servidores cómo tratar el contenido. Se fijan en la cabecera Content-Type de la respuesta HTTP y en atributos como <input type="file" accept="..."> de HTML.

Imágenes (image)

Documentos (application)

Texto (text)

Audio (audio)

Vídeo (video)

Archivos y compresión (application)

Fuentes (font)

Otros

Trabajar con tipos MIME

Configuración del servidor

Un servidor web como Apache o Nginx asocia extensiones a tipos MIME. Si esa asociación es incorrecta, el navegador no puede tratar el archivo como corresponde: un .webp sin el tipo adecuado se ofrece como descarga en vez de mostrarse como imagen.

Validación de subidas

Al construir una función de subida, comprueba el tipo MIME además de la extensión. Aun así, el tipo MIME puede falsificarse en el cliente, de modo que por seguridad conviene verificar también los magic bytes del inicio del archivo.

La cabecera Content-Type

Fija un Content-Type preciso en las respuestas de API y en las descargas: application/json para JSON y text/csv para CSV. Cuando haya que declarar la codificación, añade el parámetro charset, como en text/html; charset=utf-8.

Declarar tipos MIME en la configuración del servidor

A continuación, los fragmentos que se usan al servir formatos modernos —WebP, AVIF, WASM, fuentes web— que suelen faltar en la asignación por defecto del servidor.

Apache .htaccess

# Formatos de imagen modernos
AddType image/webp .webp
AddType image/avif .avif
AddType image/svg+xml .svg .svgz

# Fuentes: cachéalas de forma agresiva
AddType font/woff  .woff
AddType font/woff2 .woff2

# WebAssembly y las variantes modernas de JSON
AddType application/wasm        .wasm
AddType application/manifest+json .webmanifest
AddType application/ld+json     .jsonld

# Sirve el texto como UTF-8
AddCharset utf-8 .html .css .js .json .xml

Nginx (sobrescribiendo mime.types)

types {
    image/webp                webp;
    image/avif                avif;
    application/wasm          wasm;
    application/manifest+json webmanifest;
}

# Fuerza un charset en text/* y application/json
charset utf-8;
charset_types text/css text/plain text/xml application/javascript application/json application/xml;

PHP — enviar Content-Type

// Descargar un PDF con un nombre de archivo
header('Content-Type: application/pdf');
header('Content-Disposition: attachment; filename="invoice.pdf"');
readfile($path);

// Respuesta de API JSON: indica siempre el charset
header('Content-Type: application/json; charset=utf-8');
echo json_encode($data, JSON_UNESCAPED_UNICODE);

Node.js / Express

// Express deduce el Content-Type de res.type() o de la extensión
app.get('/data.json', (req, res) => {
    res.type('application/json').send({ ok: true });
});

// Transmitir un archivo con un MIME explícito
app.get('/report.csv', (req, res) => {
    res.set('Content-Type', 'text/csv; charset=utf-8');
    fs.createReadStream('report.csv').pipe(res);
});

Python — Flask / FastAPI

# Flask
from flask import Response
return Response(csv_text, mimetype='text/csv', headers={'Content-Disposition': 'attachment; filename="data.csv"'})

# FastAPI
from fastapi.responses import Response
return Response(content=json_str, media_type='application/json')

Go — net/http

w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Content-Type-Options", "nosniff")  // Seguridad: ver abajo
json.NewEncoder(w).Encode(data)

Seguridad: por qué hace falta X-Content-Type-Options: nosniff

Históricamente, los navegadores han «olfateado» el contenido de un archivo para adivinar su tipo cuando faltaba la cabecera Content-Type o era incorrecta. Es un vector de ataque conocido: si un archivo subido como image/jpeg es en realidad HTML con una etiqueta <script>, el navegador puede interpretarlo como HTML y ejecutar el script.

Envía X-Content-Type-Options: nosniff en todas las respuestas. Le dice al navegador que confíe en el Content-Type declarado por el servidor en lugar de adivinar. Es imprescindible con archivos subidos por usuarios y con APIs JSON, donde se intenta reinterpretar el JSON como HTML o JavaScript.

Validación de subidas: la regla de tres capas

1. Comprobación de la extensión — rápida, pero se burla renombrando el archivo. Trátala como una ayuda de UX, nada más.
2. El tipo MIME que envía el cliente (el Content-Type dentro del límite multipart) — igual de fácil de falsificar. El navegador lo deduce de la extensión, sin más.
3. Detección de magic bytes (firma de archivo) — lee los primeros bytes reales y compáralos con la firma conocida (FF D8 FF para JPEG, 89 50 4E 47 para PNG). Es la única capa fiable. Consulta la referencia de magic bytes para más detalle.

La regla en producción: haz las tres. Usa las dos primeras como filtros baratos que descartan la basura evidente, y la tercera como comprobación definitiva.

Preguntas frecuentes