Píxeles a unidades em
Convierta un tamaño en píxeles a em: 24 px dentro de un padre de 16 px son 1,5 em, listos para pegar como 1.5em. Así el texto y los espacios crecen con la fuente del padre y con los ajustes del lector. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Px
- 24
- Elemento padre
- 16
- Em
- 1,5
- Em (CSS)
- 1.5em
- Razón
- 1,5
- Precisión
- 10
Este conversor de píxeles a em transforma un tamaño de fuente CSS expresado en píxeles en unidades em usando el tamaño de fuente del elemento padre como base de referencia. La identidad empleada es plenamente determinista: em es igual a px dividido por el padre. Diseñadores, ingenieros frontend y auditores de accesibilidad usan esta conversión al reescribir escalas tipográficas fijas en hojas de estilo escalables que crecen con la configuración de fuente del usuario y el contexto de componentes anidados. El motor usa solo aritmética finita, sin llamadas de red, sin muestreo y sin atajos dependientes de la fecha.
Dónde encaja la conversión px a em en design systems, CSS y software
Los design systems a menudo guardan tokens de espaciado y tipografía en píxeles para las herramientas de diseño, mientras el CSS de producción prefiere em para componentes anidados que deben escalar con el tamaño de fuente local; un conversor determinista único evita el desfase de la calculadora manual cuando un diseñador, un ingeniero frontend o un estudiante reescribe una hoja de estilo.
Las auditorías de accesibilidad convierten rellenos fijos en píxeles y tamaños ligados a la línea en em para que el zoom de texto y la configuración de fuente del usuario agranden los objetivos de pulsación de forma proporcional; las plantillas de correo y las pieles heredadas aún mezclan longitudes absolutas y relativas y necesitan una comprobación rápida sin conexión antes de un lanzamiento.
Los docentes asignan deberes que exigen una verificación rápida de cuerpo a dieciséis píxeles y encabezados a veinticuatro sin confiar en aplicaciones opacas que cambian en silencio a rem o omiten la base del padre. Los desarrolladores invocan el mismo contrato desde scripts para sembrar vectores de prueba deterministas para generadores de temas, normalizar tamaños introducidos por el usuario antes de dimensionar demos, o satisfacer enunciados de retos de programación que exigen ratios exactos en lugar de una estimación aproximada.
Las herramientas de producto usan la reescritura cuando un aprendiz o un agente escribe veinticuatro píxeles y un padre de dieciséis y la interfaz debe mostrar uno coma cinco em junto al eco en píxeles. Mantenga las herramientas rem o de viewport aparte cuando la referencia sea la raíz en cascada o el viewport en lugar del tamaño de fuente del padre, y mantenga este conversor enfocado cuando la pregunta sea estrictamente de píxeles a unidades em para tipografía escalable y accesible.
Qué puede hacer con ella
Tokens de diseño y escalas tipográficas
Convierta tokens de tipografía y espaciado en píxeles a em para que los componentes anidados escalen con el tamaño de fuente del padre.
Reescritura de hojas de estilo y accesibilidad
Reescriba tamaños de fuente fijos en píxeles a em para que el zoom de texto y la fuente del usuario agranden el diseño de forma proporcional.
Preguntas frecuentes
¿Cuánto cuesta el conversor de píxeles a em?
Es gratis en su navegador en esta página.
¿Cómo se relacionan los píxeles y el em?
Con un tamaño de fuente del padre en píxeles, em = px / parent. Un em equivale al tamaño de fuente del padre, así que 24px con parent 16 produce 1.5em.
¿Qué ocurre si el tamaño de fuente del padre es cero?
Un parent cero hace que em = px/parent sea indefinido (división por cero).
¿Esta herramienta convierte em de nuevo a píxeles, o rem?
No. Esta capacidad solo convierte píxeles a em dado un tamaño de fuente del padre explícito en píxeles. Use herramientas dedicadas para la conversión inversa o a rem.
¿Por qué los resultados se redondean a una precisión?
La precisión por defecto es 10 decimales; puede fijar precision de 0 a 15.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/str/px-to-em \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"px":24,"parent":16}'const res = await fetch("https://api.kit.forhosting.com/str/px-to-em", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"px": 24,
"parent": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/px-to-em",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"px": 24,
"parent": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/px-to-em", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"px":24,"parent":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"px":24,"parent":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/px-to-em", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"px": 24,
"parent": 16
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.px_to_em",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_abs_value | 1000000000000000 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
La tipografía relativa depende de esa base: un em equivale al tamaño de fuente calculado del padre, de modo que veinticuatro píxeles con un padre de dieciséis píxeles son uno coma cinco em, y catorce píxeles con el mismo padre son cero coma ocho siete cinco em.
Qué significan los píxeles y el em y qué contiene la respuesta
Una conversión CSS de píxeles a em responde a una pregunta de maquetación concreta: dado un tamaño de fuente o una longitud de espaciado en píxeles y el tamaño de fuente del elemento padre en píxeles, cuál es la magnitud equivalente en em para que el tipo, el relleno y los tamaños de componente sigan proporcionales cuando cambian la cascada o el zoom del usuario. Los píxeles son longitudes absolutas independientes del dispositivo en CSS; el em es relativo al tamaño de fuente calculado del elemento padre, de modo que el mismo valor em se escala automáticamente al cambiar la fuente del padre. Cero es un valor px válido y simplemente produce cero em, útil al vaciar un token de tamaño o al afirmar un espaciado vacío. Esta calculadora acepta un valor numérico px y un tamaño de fuente del padre en píxeles, y devuelve el resultado em redondeado a una precisión estable, una cadena compacta em_css como 1.5em lista para pegar en una hoja de estilo, las entradas ecoadas, un campo ratio igual al resultado em para claridad en tablas, y un breve recordatorio de la fórmula. En esta página no hay camino inverso de em a px, ni búsqueda de raíz rem, ni matemática de viewport, ni simulación de media-query: el motor divide px entre parent dentro del rango de magnitud admitido o rechaza la entrada con invalid_input. Los casos rechazados incluyen px o parent ausentes, números no finitos, magnitudes por encima del techo documentado, y cualquier parent cero o numéricamente cero, porque em igual a px entre parent dividiría por cero.
Cómo se leen px, parent y precision y cómo se reproducen los resultados
Se admite notación científica opcional en cadenas numéricas cuando se parsea como decimal finito; espacios embebidos, prefijos hex y tokens no numéricos se rechazan con un mensaje claro para que una celda errónea de hoja de cálculo no se convierta en un tamaño de tipo incorrecto. El cálculo es una sola división: em es igual a px dividido por parent. Los docentes también pueden usar el mismo contrato para corregir tareas que piden convertir una escala tipográfica en píxeles a em para encabezados y cuerpo anidados. Los campos preferidos son px para la magnitud en píxeles y parent para el tamaño de fuente del padre en píxeles, con alias pixels, size, font_size, value y amount para el campo de píxeles, y base, parent_px, parent_font_size, base_font_size y root para el campo parent, de modo que clientes heterogéneos compartan un solo contrato. Un parent cero siempre falla con invalid_input porque la conversión relativa a em no está definida sin un tamaño de fuente del padre distinto de cero. Un campo opcional precision, con alias decimals y dp, elige cuántos decimales exponer para px, parent, em y ratio, con valor por defecto diez y tope quince para que los goldens JSON se mantengan estables entre runtimes. Combine la ejecución gratuita en el navegador de esta página con la API de pago cuando necesite el mismo resultado matemático dentro de un pipeline automatizado sin reimplementar usted mismo la matemática tipográfica.
Dónde encaja la conversión px a em en design systems, CSS y software
En esta página el trabajo se ejecuta por completo en su navegador; a través de la API cada consulta correcta cuesta $0.002, la validación fallida no se cobra y no se almacena nada tras devolver la respuesta. Esa división — exploración interactiva gratuita y una API idéntica de pago — coincide con el resto del catálogo KIT de nivel A y le permite pasar de una demo de aula a un pipeline automatizado sin cambiar el resultado matemático.
Casos de integración
Fixtures deterministas de CI
Genere pares px→em reproducibles para generadores de temas, pruebas unitarias y pipelines de design systems.