Convert pixels to centimeters based on your screen's DPI (dots per inch).
This PX to CM converter turns pixel values into centimeters instantly, using the DPI of your screen or output medium. No guesswork. Just accurate results.
Pixels have no fixed physical size. A pixel on a low-resolution monitor is much larger than one on a high-density display. DPI (dots per inch) is the bridge between digital and physical units. Get it wrong and your measurements are off.
The formula is straightforward:
cm = px / DPI × 2.54
Use the right DPI for your context and the result is exact.
It depends on where your design or document ends up. Different environments have different standards.
| Context | Typical DPI | Notes |
|---|---|---|
| Legacy web / older monitors | 72 | Historical Mac standard |
| Standard web / Windows | 96 | Default for most browsers |
| Hi-DPI screens | 120 | Common on mid-range laptops |
| Retina / 2x displays | 144+ | MacBook Pro, high-end monitors |
| Print (standard quality) | 300 | Minimum for sharp printed output |
If you are unsure of your screen's DPI, check Settings > Display on Windows or System Settings > Displays on macOS.
For further reading on screen resolution and pixel density standards, see the W3C CSS absolute length specification.
A PX to CM converter is a calculation tool that translates pixel values into centimeters using screen resolution (PPI) as the connecting variable.
Pixels are screen-relative units with no fixed physical size. Centimeters are absolute physical units that always measure the same in the real world. A converter bridges these two entirely different measurement systems.
Most online converters assume 96 PPI, the CSS default set by the W3C specification since CSS2.1 (2011). At that resolution, 1 px = 0.026458 cm.
Who uses it regularly:
Web designers moving assets into print layouts
Front-end developers writing CSS print stylesheets
Print designers receiving digital specs in pixels
Packaging teams converting screen mockups to physical dimensions
The conversion isn't one-size-fits-all. Changing the PPI value changes the centimeter output entirely. A 100 px element at 72 PPI produces a different physical size than 100 px at 300 PPI.
A pixel is the smallest addressable unit on a screen display. But that definition only covers half of it.
There are actually 2 distinct types: CSS pixels (device-independent) and physical pixels (hardware-level). Conversion tools work exclusively with CSS pixels, not physical ones.
|
Pixel Type |
Definition |
Used In |
|---|---|---|
|
CSS pixel |
Abstract unit, 1/96 of an inch |
All web browsers, CSS calculations |
|
Physical pixel |
Hardware dot on a screen |
Device specs, display panels |
|
Device pixel ratio |
CSS px to physical px relationship |
High-DPI scaling, Retina displays |
The CSS specification defines 1 px as exactly 1/96 of an inch. That ratio has been fixed since CSS2.1. It was standardized because too much existing web content relied on the 96 PPI assumption, and breaking it would have broken those layouts (W3C CSS Working Group).
Apple introduced Retina displays in 2010, and almost nothing in web unit math has been straightforward since.
Retina and high-DPI screens use a device pixel ratio of 2, 3, or sometimes 3.5. One CSS pixel on a 2x screen maps to 4 physical pixels (2x2 grid). The physical size stays roughly the same; the sharpness doubles.
Most modern devices now have a device-pixel-ratio between 1.0 and 4.0 (web.dev, 2024). At 192 PPI, the ratio is exactly 2 (192 ÷ 96 = 2).
For PX to CM conversion, this doesn't change the formula. The formula always uses CSS pixels at the target PPI, not physical pixels.
A centimeter is 1/100 of a meter. It's a fixed physical unit that measures the same regardless of the screen it's viewed on, the software displaying it, or the device rendering it.
1 inch = 2.54 cm. That relationship is exact and non-negotiable. It's the anchor for every PX-to-CM formula in existence.
Where centimeters are the standard:
Print design (brochures, posters, business cards, packaging)
Physical product specs and packaging dimensions
Document layout in Microsoft Word and Google Docs (EU default ruler unit)
Adobe InDesign and CorelDRAW print templates
The centimeter is fully device-independent. A 5 cm logo on a poster is 5 cm whether it's printed at 72 DPI or 300 DPI. The pixel version of that logo changes size depending entirely on the target resolution.
That's the core tension designers run into when moving work between screen and print.
CM = (PX ÷ PPI) × 2.54
That's it. Two operations. The PPI value is the only variable that changes between use cases.
At the 96 PPI standard used by all web browsers and most online converters:
1 px = 0.026458 cm
100 px = 2.6458 cm
300 px = 7.9375 cm
1920 px = 50.8 cm
Worked example: a 1200 px wide banner at 96 PPI → (1200 ÷ 96) × 2.54 = 31.75 cm
The math is fast. The risk is assuming the wrong PPI.
PPI directly controls physical output size. This is where most conversion errors happen. Designers often feed a pixel value into a converter without confirming the PPI that tool assumes.
|
PPI Value |
Context |
1 px in CM |
|---|---|---|
|
72 PPI |
Legacy Mac standard, some print workflows |
0.03528 cm |
|
96 PPI |
W3C CSS default, all major browsers |
0.026458 cm |
|
120 PPI |
Windows display scaling at 125% |
0.02117 cm |
|
150 PPI |
Windows scaling at 156% |
0.01693 cm |
|
300 PPI |
Standard print resolution |
0.00847 cm |
A 500 px logo at 72 PPI prints at 17.64 cm. The same 500 px at 300 PPI prints at 4.23 cm. Wrong PPI assumption, wildly wrong physical output.
Upgrading a 72 PPI web graphic to print-ready 300 DPI demands 16.7 times more pixels (Hua Xian Jing, 2025). That scale difference explains why PPI verification matters before any conversion.
All values calculated at 96 PPI (CSS default). This is the standard assumption for web-to-print workflows.
|
PX |
CM |
Rounded CM |
|---|---|---|
|
1 |
0.026458 |
0.03 cm |
|
5 |
0.13229 |
0.13 cm |
|
10 |
0.26458 |
0.26 cm |
|
16 |
0.42333 |
0.42 cm |
|
24 |
0.63500 |
0.64 cm |
|
32 |
0.84667 |
0.85 cm |
|
48 |
1.27000 |
1.27 cm |
|
64 |
1.69333 |
1.69 cm |
|
96 |
2.54000 |
2.54 cm |
|
100 |
2.64583 |
2.65 cm |
|
128 |
3.38667 |
3.39 cm |
|
192 |
5.08000 |
5.08 cm |
|
256 |
6.77333 |
6.77 cm |
|
300 |
7.93750 |
7.94 cm |
|
500 |
13.22917 |
13.23 cm |
|
1000 |
26.45833 |
26.46 cm |
|
1920 |
50.80000 |
50.80 cm |
A few values worth noting:
96 px = 2.54 cm (exactly 1 inch at 96 PPI, a useful sanity check)
16 px is the default browser root font size (1rem), equal to 0.42 cm
1920 px is Full HD screen width, which converts to exactly 50.8 cm at 96 PPI
The most common desktop screen resolution in 2023 was 1920×1080, used by 22.18% of users (Devzery, 2024). Knowing that 1920 px = 50.8 cm at 96 PPI is a practical reference for any full-width print export.
PX = (CM ÷ 2.54) × PPI
Divide centimeters by 2.54 to get inches, then multiply by the target PPI.
At 96 PPI: 1 cm = 37.7953 px
Worked examples:
5 cm → (5 ÷ 2.54) × 96 = 188.976 px (round to 189 px)
10 cm → (10 ÷ 2.54) × 96 = 377.953 px
21 cm (A4 width) → (21 ÷ 2.54) × 96 = 793.701 px
29.7 cm (A4 height) → (29.7 ÷ 2.54) × 96 = 1122.52 px
The A4 conversions are useful for designers building print-ready Figma frames. A standard Letter page (8.5 × 11 in) converts to 816 × 1056 px at 96 PPI (Rechat Help Center, 2025).
For print work at 300 PPI, the same A4 width (21 cm) becomes 2480 px and A4 height becomes 3508 px. That's why print files are much heavier than screen files.
CM to PX reference table at 96 PPI:
|
CM |
PX (exact) |
PX (rounded) |
|---|---|---|
|
0.5 |
18.897 |
19 px |
|
1 |
37.795 |
38 px |
|
2 |
75.591 |
76 px |
|
3 |
113.386 |
113 px |
|
5 |
188.976 |
189 px |
|
10 |
377.953 |
378 px |
|
21 |
793.701 |
794 px |
|
29.7 |
1122.520 |
1123 px |
Need the reverse of this? The CM to PX converter handles these calculations automatically.
For other unit conversions in the same family, PX to MM and PX to Inches follow the same PPI-dependent logic.
PX to CM conversion shows up any time a design crosses the boundary between screen and print.
Print-to-screen handoff is the most common scenario. A brand delivers a logo at 5 cm wide for business cards. The web developer needs the pixel equivalent to match it in a digital header. At 96 PPI, that's 189 px. At 300 PPI for a high-res asset, it's 591 px.
Email design is a trickier case. Some email clients render in screen pixels, others interpret physical dimensions depending on the device and client settings. Designers working across both need to verify pixel-to-centimeter equivalents for consistent rendering.
CSS @media print stylesheets are where this conversion becomes a developer problem. CSS print stylesheets support absolute units including cm, mm, in, pt, and pc. Screen layouts built in px require manual conversion before they translate correctly to a printed page (SitePoint, 2023).
Packaging design in Adobe Illustrator or CorelDRAW uses centimeters and millimeters by default. Any digital asset built in pixels that needs to fit onto physical packaging requires exact conversion.
This is the area developers most often get wrong.
@media print accepts both screen units (px) and absolute print units (cm, mm, in). But the browser interprets them differently depending on rendering context.
@media print {
.container {
width: 21cm;
margin: 2cm;
font-size: 12pt;
}
}
At browser default 96 PPI, width: 21cm resolves to 793.7 px. A container set to 780 px in the screen stylesheet would need to be changed to 20.64cm in the print stylesheet to maintain the same physical width.
CSS Paged Media tools like Prince have stronger support for print-specific unit rendering than standard browsers (DiDoesDigital, 2024). For production print stylesheets where exact physical dimensions matter, a dedicated CSS Paged Media converter gives more reliable results than browser print preview alone.
For other CSS unit conversions relevant to this workflow, PX to PT and PT to CM cover the typography-specific conversions that appear in print stylesheets. The PT to PX conversion is also useful when working with font sizes specified in points that need to match screen layouts.
The PPI value fed into the conversion formula controls everything. Use the wrong one and the physical output is wrong, full stop.
Average desktop PPI climbed to 105 in 2024, up from 92 in 2020 (Gitnux, 2024). Smartphone average PPI hit 420 in 2024, up from 350 in 2019. These numbers matter because neither 72 nor 96 PPI reflects most real devices today.
|
PPI Value |
Device Context |
100 px = (CM) |
|---|---|---|
|
72 PPI |
Legacy Mac, some print workflows |
3.528 cm |
|
96 PPI |
W3C CSS default, all browsers |
2.646 cm |
|
120 PPI |
Windows scaling at 125% |
2.117 cm |
|
192 PPI |
2x Retina (MacBook, iPhone) |
1.058 cm |
|
264 PPI |
iPad Pro 12.9-inch (6th gen) |
0.962 cm |
|
300 PPI |
Standard print resolution |
0.847 cm |
For screen-to-screen work: always use 96 PPI. Browsers calculate CSS units at 96 PPI regardless of the physical hardware underneath.
For screen-to-print work: use the printer's actual DPI. Most commercial printers require 300 DPI. A 4-inch wide web graphic at 72 PPI jumps to 1200×1800 px when resized to print quality at 300 DPI, roughly a 16.7x increase in pixel count (Hua Xian Jing, 2025).
High-DPI screens don't change the CSS conversion formula. They do change what developers assume about sharpness.
A MacBook Pro 15-inch (220 PPI) uses a device pixel ratio of 2, meaning 1 CSS px = 4 physical pixels (2×2 grid). The CM conversion still uses 96 PPI as the reference. Physical display density only matters when exporting raster assets for screen, not when calculating print dimensions.
Smartphones now hold a device-pixel-ratio between 3 and 4 on flagship models (Samsung Galaxy S24 Ultra: 505 PPI; Sony Xperia 1 V: 643 PPI). A 390 px wide mobile layout at CSS level stays 390 CSS px wide regardless. Its CM equivalent stays 10.319 cm at 96 PPI.
Windows display scaling adds a layer that trips up most developers who test on a single machine.
100% scaling: 96 PPI, 1 CSS px = 1 device px
125% scaling: effectively 120 PPI reference
150% scaling: effectively 144 PPI reference
200% scaling: 192 PPI, same ratio as 2x Retina
When a Windows user at 150% scaling opens a web page, the browser scales CSS pixels up. A 100 px element still measures 2.646 cm in CSS. But if a developer screenshots that element and measures it on screen physically, it will appear larger than 2.646 cm because of OS-level scaling.
For print conversions, always confirm which PPI the target output device actually uses.
Every major tool has its own opinion about units, and none of them agree entirely. Knowing each tool's default behavior prevents conversion errors before they happen.
Figma is pixel-only by default. It has no native support for inches, centimeters, millimeters, or points (Designilo, 2025). Designers building print materials in Figma must either calculate px equivalents manually or install a plugin. The "Unit Converter" and "Uniter" plugins on Figma Community handle cm-to-px conversions within the canvas.
Adobe Illustrator defaults to points (pt) for new documents, but supports px, cm, mm, in, and pica. Illustrator's default PPI is 72, not 96. A 100 px object in Illustrator at 72 PPI prints at 3.528 cm. The same 100 px value in a browser prints at 2.646 cm. That 0.88 cm difference compounds across complex layouts.
Adobe Photoshop creates new documents by letting the user set resolution. Print documents typically open at 300 PPI. At 300 PPI, 1 cm = 118.11 px, so a 10 mm × 10 mm square requires a 118.11 × 118.11 px canvas (Figma Forum, 2022).
|
Tool |
Default Unit |
Default PPI |
Native CM Support |
|---|---|---|---|
|
Figma |
px |
96 (CSS) |
No (plugin required) |
|
Adobe Illustrator |
pt |
72 |
Yes |
|
Adobe Photoshop |
px |
User-set |
Yes |
|
Adobe InDesign |
mm/in |
User-set |
Yes |
|
Microsoft Word |
cm (EU) / in (US) |
N/A |
Yes |
Figma exports rasterized assets (PNG, JPG) at 1x, 2x, 3x, or 4x scale.
At 1x export (96 PPI equivalent): a 1920 px frame exports at 50.8 cm physical width if printed.
At 4x export: the same frame becomes 7680 px wide, which at 300 PPI produces a print-ready 65.1 cm output. The formula stays the same: (7680 ÷ 300) × 2.54 = 65.02 cm.
Figma's export dialog does not label the DPI of the output directly. The multiplier (1x, 2x, 3x) only increases pixel dimensions. Actual physical print size depends on the DPI setting at the printer end, not the multiplier chosen in Figma.
Illustrator's unit system is genuinely flexible, but the default PPI of 72 is a trap for developers.
When the ruler unit is switched to centimeters (right-click ruler > Centimeters), all measurements, guides, object dimensions, and grid spacing update to CM. A logo frame set to 25 × 30 cm in Illustrator renders at 70.87 × 85.04 px at 72 PPI. At 96 PPI that same frame is 94.49 × 113.39 px.
The fix is straightforward: set document raster effects settings to the correct DPI before starting work. For print: 300 DPI. For screen: 72 or 96 PPI depending on export target.
Typography units have a specific hierarchy in CSS, and the relationships between them are fixed, not approximate.
1 pt = 1/72 inch. At 96 PPI: 1 pt = 1.333 px. Print typography runs on points. Screen typography runs on px or rem. Physical layout uses cm or mm. Mixing these without conversion produces mismatched visual sizes across output media.
The full conversion chain at 96 PPI:
12 pt = 16 px = 0.423 cm
14 pt = 18.66 px = 0.494 cm
18 pt = 24 px = 0.635 cm
36 pt = 48 px = 1.270 cm
72 pt = 96 px = 2.540 cm (exactly 1 inch)
The default browser font size is 16 px across all major browsers (Chrome, Firefox, Safari, Edge). That means 1 rem = 16 px = 0.423 cm at 96 PPI. Knowing this conversion is useful when translating a print spec (written in pt or cm) to a CSS font-size value.
PT (point) is a fixed physical unit: 1/72 of an inch, always. It renders the same physical size whether on screen or paper, at any PPI.
PX is a CSS reference unit. On screen it produces a visually consistent size; on paper at 96 PPI it resolves to exactly 1/96 of an inch.
Fhoke research (2025) confirms that for most typography and layout spacing, rem units are the preferred choice in modern web development, offering better accessibility and scalability than px. Pixel-based font sizes don't respond to browser font-size preferences, which matters for the estimated 2.2 billion people globally with vision impairments who increase default text size.
For a full breakdown of related unit conversions in typography, the PX to EM converter and REM to PX converter cover the relative unit side. The EM to PX and REM to EM converters handle the reverse.
CM rarely appears in screen typography. It shows up in 3 specific contexts:
CSS @media print stylesheets with font-size in pt or cm
Microsoft Word and Google Docs paragraph spacing (line spacing in cm)
Adobe InDesign body text with leading specified in mm
At 96 PPI, a 12 pt body font equals 0.423 cm. A typical printed A4 page body text block running 25 cm tall at 12 pt / 1.5 line height fits approximately 59 lines of text. That calculation requires the full conversion chain: pt to px to cm.
The Type Scale Generator automates typographic hierarchy across px, pt, rem, and em values simultaneously.
Most people reach for a converter because they want a fast answer, not a math lesson. The tools are simple. The gotcha is the PPI assumption hiding in every one of them.
Every major online converter defaults to 96 PPI unless the user changes it. UnitConverters.net, RapidTables, and CSSUnits.com all follow this pattern. For web-to-screen work, that's correct. For web-to-print work at 300 DPI, it produces the wrong physical size.
The practical test before trusting any converter: enter 96 px and check that the result is exactly 2.54 cm. If it is, the tool runs at 96 PPI. If the result is 3.528 cm, it runs at 72 PPI.
Standard web converters (RapidTables, UnitConverters.net):
Input: single PX value
Output: CM at 96 PPI
No custom PPI field
Fine for CSS and screen work
Advanced converters with PPI input (some Figma plugins, specialized tools):
Accept any PPI value
Useful for print handoffs at 150, 300, or 600 DPI
Required for accurate packaging and label design conversions
The distinction matters most in print workflows. A Shopify store that cut product return rates by 22% after fixing image resolution issues traced 63% of complaints back to incorrect pixel-to-physical-size assumptions (Hua Xian Jing, 2025).
Browser DevTools shows computed CSS values in px. There is no built-in CM display.
The workflow for converting a live page element to CM:
Inspect the element in DevTools
Read the computed width or height in px
Apply the formula: (px ÷ 96) × 2.54
Chrome DevTools does not show physical units, even when the CSS source uses cm or mm. The browser converts all absolute units to px internally at render time, then displays the px equivalent in computed styles.
For color-related conversions that often accompany print design workflows, the RGB to CMYK converter and CMYK to RGB converter handle the color space side. Print design also frequently requires the HEX to Pantone Converter and Pantone to CMYK converter when preparing files for offset printing.
For other dimension-related tools in the same workflow, the MM to PX converter and Inch to PX converter handle the other absolute unit conversions used in print spec handoffs. The EM to REM converter covers the relative unit side for developers scaling up from component-level to document-level typography.
At the standard 96 PPI used by web browsers, 1 px equals 0.026458 cm.
That value comes from the formula: (1 ÷ 96) × 2.54. Change the PPI and the result changes with it.
The formula is: CM = (PX ÷ PPI) × 2.54.
Divide the pixel value by your screen or print resolution in PPI, then multiply by 2.54 (the number of centimeters in one inch). Most online tools default to 96 PPI.
PPI controls the physical size of a pixel. At 72 PPI, 100 px = 3.528 cm. At 300 PPI, 100 px = 0.847 cm.
Same pixel count, completely different physical output. Always confirm the target PPI before converting for print.
At 96 PPI, 1 cm = 37.7953 px.
For print at 300 PPI, 1 cm = 118.11 px. The difference is significant. Using the wrong value when building print-ready assets will produce incorrect physical dimensions.
No. Figma works exclusively in pixels and has no built-in CM support.
Designers use community plugins like Unit Converter or Uniter to convert centimeters and millimeters to pixel values inside Figma. Always verify the DPI setting each plugin assumes before applying conversions.
Use 300 PPI for standard commercial print (business cards, brochures, posters).
Some large-format prints (banners, billboards) use 72–150 PPI because viewing distance reduces the need for high pixel density. Web design stays at 96 PPI.
CSS natively supports centimeters. Write width: 5cm directly in a stylesheet.
For @media print stylesheets, browsers resolve 1cm to 37.7953 px at 96 PPI. If you need to calculate the cm equivalent of a pixel value manually, apply: (px ÷ 96) × 2.54.
An A4 page is 21 × 29.7 cm. At 96 PPI, that converts to 793.7 × 1122.5 px.
At 300 PPI for print, A4 becomes 2480 × 3508 px. Figma users building print frames should set canvas size to the 96 PPI pixel equivalent, then export at a higher multiplier.
No. At 96 PPI, 1 pt = 1.333 px, because 1 pt is 1/72 of an inch and 1 px is 1/96 of an inch.
Print typography uses points. Screen typography uses px or rem. The conversion chain is: 12 pt = 16 px = 0.423 cm.
Accurate, as long as the PPI assumption matches your project. Most tools default to 96 PPI.
To verify, enter 96 px and check the result equals exactly 2.54 cm. If it returns 3.528 cm, the tool runs at 72 PPI and will produce incorrect results for web-to-print workflows.