ForHosting KIT · Text & AI

Pixels to points converter

Turn screen pixel sizes into print points: at the web standard of 96 DPI, 16 px becomes 12 pt, each pixel worth three quarters of a point. Set another resolution, such as 300 DPI for print, and the one used is always shown. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Px: 16

You get

Dpi: 96
Pt: 12
Inches: 0.1666666667
Factor: 0.75

Screen mockups and CSS style guides speak in pixels, while print specifications, desktop publishing packages, and press proofs speak in typographic points. A sixteen-pixel body size on a standard web canvas is not the same physical mark as a sixteen-pixel glyph rendered at three hundred DPI for a brochure, so you need a clear conversion that states the DPI assumption. This pixels to points converter applies the industry relation that one inch equals seventy-two points and one inch equals dpi pixels, so pt equals px times seventy-two divided by dpi. When you omit dpi the tool uses the CSS reference of ninety-six, which yields the familiar mapping of sixteen pixels to twelve points. Designers, frontend engineers, and prepress operators can paste a font size from a design file and obtain a print-ready point value without opening a layout application or re-deriving the constant by hand.

Why pixels and points are different units

A pixel is a sample on a digital canvas; its physical size depends on the device resolution. A typographic point is a fixed length used in print: under the PostScript and CSS convention there are exactly seventy-two points in one inch. Because one inch also contains dpi device pixels (or CSS reference pixels when you adopt the web standard of ninety-six), the conversion is a single proportion: points equal pixels times seventy-two divided by dpi.

At ninety-six DPI each pixel is three quarters of a point, so a sixteen-pixel paragraph size becomes twelve points—the body size many print styles treat as a comfortable default. At seventy-two DPI a pixel and a point coincide, which is why some older screen-to-print pipelines treat them interchangeably and then surprise operators when a high-density export shrinks type.

At three hundred DPI, common for photo and commercial print, each pixel is only a quarter of a point, so a font that looks large on a phone preview may become tiny on paper if you copy the pixel number into a point field without scaling. This capability always returns the dpi it used, the intermediate size in inches, and the multiplication factor so you can audit the assumption next to the answer instead of trusting a silent default.

Where converting pixels to points pays off

Design systems that ship both web CSS and print brand books need a single oracle so sixteen pixels on the marketing site maps to twelve points in the letterhead PDF when the CSS reference DPI is assumed. Frontend teams handing specs to print vendors can convert computed styles from the browser into point sizes editors expect, avoiding the common mistake of pasting raw pixel numbers into a body-size field.

Prepress scripts and DAM pipelines convert exported UI measurements into press units before imposing pages, and exam or courseware generators that teach CSS and DTP side by side can show the formula with live numbers. Failed validation does not consume balance. Keep requests tiny, pin the rounded pt field in tests, and you get reproducible print specs for design tokens, style guides, and edge workers without standing up a full typesetting stack of your own.

What you can do with it

Web-to-print font handoff

Convert CSS font sizes in pixels into point sizes for print brand books and PDF templates that still expect PostScript points.

Design-token sync

Keep design-system tokens consistent: map 14px / 16px / 24px scales to pt at 96 DPI for dual web and print documentation.

FAQ

How do I convert pixels to points?

Send px (required) and optionally dpi (default 96). At the CSS default, 16px becomes 12pt.

What DPI does the converter use by default?

It uses 96, the CSS reference resolution where 1px = 0.75pt. Override dpi when matching a device or print density.

Can I convert at print resolutions like 300 DPI?

Yes. Set dpi to 300 (or any positive finite value). For example, 300px at 300 DPI is 72pt (one inch).

What happens if px or dpi is zero or negative?

Pixel sizes and DPI must be finite positive numbers; bad input is not billed.

Are pixels and points the same at 72 DPI?

Yes. At 72 DPI one pixel equals one point, which is why some older screen-to-print workflows treat them as interchangeable, and then type shrinks unexpectedly when a high-density export is used.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/str/px-to-pt

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/str/px-to-pt \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"px":16}'

const res = await fetch("https://api.kit.forhosting.com/str/px-to-pt", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "px": 16
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/str/px-to-pt",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "px": 16
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/px-to-pt", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"px":16}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"px":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/px-to-pt", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "px": 16
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.px_to_pt",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

Input contract, defaults, and response fields

The optional field dpi sets the resolution in dots or CSS pixels per inch; if omitted it defaults to ninety-six so browser-centric callers get the CSS mapping without extra fields. Zero or negative dpi fails the same way because a non-positive resolution would invert or destroy the geometry. Example: px equals sixteen with default dpi yields pt equals twelve, inches equals one sixth, and factor equals zero point seven five. POST a JSON body with the required field px: a finite positive number for the size in pixels. You may also send pixels, value, size, or font_size_px as aliases when an upstream form already uses those names. Aliases resolution, ppi, and screen_dpi are accepted for the same parameter. Zero, negative, non-finite, and missing px values fail with invalid_input and are not billed. On success the response echoes px and dpi, returns pt rounded to twelve decimal places for stable goldens, returns inches as px divided by dpi, returns factor as seventy-two divided by dpi so clients can convert more sizes offline, and returns a formula string that restates the arithmetic in human-readable form plus method equal to px_to_pt. Pair the point result with your print stylesheet or InDesign character style; this endpoint does not render glyphs or generate PDFs.

Integration use cases

Prepress and DAM scripts

Automate conversion of exported UI measurements into press units before imposition, using an explicit DPI on every call.

Technical questions

What does the pixels to points converter cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free