Points to pixels converter
12 points are 16 CSS pixels. Convert type sizes between points, pixels and picas with the CSS rule of 96 pixels and 72 points per inch, to move print specs from InDesign or a style guide into web pages and emails. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 12
- Source unit
- Pt
- Target unit
- Px
- Result
- 16
- From label
- point
- To label
- pixel
- Points
- 12
A points to pixels converter turns a typographic size written in one unit into another without hunting print tables or rewriting CSS calc formulas.
Supported units and how the 96 DPI conversion is computed
The converter accepts three typographic families under stable canonical codes: pt for the PostScript and CSS point equal to one seventy-second of an inch, px for the CSS reference pixel at ninety-six dots per inch equal to one ninety-sixth of an inch, and pc for the pica equal to twelve points. Factors follow the CSS absolute-length model: one point is one point, one pixel is three quarters of a point because seventy-two divided by ninety-six equals zero point seven five, and one pica is exactly twelve points.
Equivalently, one inch equals ninety-six pixels, seventy-two points, and six picas, so one point is four thirds of a pixel and one pica is sixteen pixels. Because the intermediate is always points, converting A to B and B to A is consistent up to the published rounding of twelve decimal places, and there is no pairwise matrix that can drift out of sync.
Device-pixel ratios, physical screen DPI overrides, em and rem relative units, millimeters, and inches are intentionally out of scope so designers and engineers get predictable typography-only results under one clear CSS convention.
Everyday use in print and web design
Use the free in-browser points to pixels converter when you need a quick twelve-point to sixteen-pixel check, a pica-to-pixel print-to-web bridge, or a pixel-to-point back-conversion while reading a style guide, Figma export, InDesign spec, or CSS absolute-length table. Open the page, enter the number and units, and copy the result without installing a desktop unit calculator, a print spreadsheet, or a local font-metric library. Source inputs follow the same retention rules as other KIT parse items, and results are safe to cache because the algorithm is fully deterministic.
Authors shipping design tools or chatbots can map the result, points, dpi, and formula fields directly into cards that show both the number and the conversion path designers, developers, and print technicians expect on paper.
What you can do with it
Print-to-web handoff
Normalize picas and points from InDesign or Quark specs into CSS pixels when building email templates, landing pages, and PDF-to-HTML previews.
FAQ
Which units does this points to pixels converter support?
Points (pt), CSS pixels (px), and picas (pc).
How do I convert 12 points to pixels?
The response result field is 16, plus a points intermediate, dpi: 96, and a readable formula.
What happens if I send an unknown unit?
The message names the field and lists supported units (pt, px, pc). Validation failures are not charged.
Is the points to pixels converter free?
The browser tool runs free on your device.
Does it account for screen resolution or high-density displays?
No. It uses the CSS reference pixel at 96 dpi. Device-pixel ratios, screen DPI settings and relative units such as em and rem are outside this converter.
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
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/conv/typography-pt-px \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":12,"from":"pt","to":"px"}'const res = await fetch("https://api.kit.forhosting.com/conv/typography-pt-px", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 12,
"from": "pt",
"to": "px"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/typography-pt-px",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 12,
"from": "pt",
"to": "px"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/typography-pt-px", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":12,"from":"pt","to":"px"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":12,"from":"pt","to":"px"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/typography-pt-px", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 12,
"from": "pt",
"to": "px"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.typography_pt_px",
"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
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
The browser tool runs free on your device; the prepaid API charges $0.002 per successful item when design pipelines need the same contract from servers and automation.
Supported units and how the 96 DPI conversion is computed
Friendly aliases such as point, points, pixel, pixels, pica, and picas are normalized case-insensitively so forms and APIs can pass either short codes or full names. Every request multiplies the input value by the exact points-per-unit factor for the source, then divides by the points-per-unit factor for the target.
Request shape, response fields, and unknown-unit errors
The error message names the bad field and lists the supported set so clients can correct forms without guessing. Negative values are allowed when you need signed size deltas in layout pipelines; zero converts cleanly to zero in every target unit. Send a JSON body with three required fields: value as a finite number, from as the source unit string, and to as the target unit string. Aliases amount, quantity, and size are accepted for value; unit_from and source for from; unit_to and target for to. On success the response echoes the canonical from and to codes, human-readable from_label and to_label strings, the converted result, the intermediate points quantity, the dimensionless factor from source to target, the fixed dpi field equal to ninety-six, a short formula line suitable for UI display, the method tag typography_96dpi, and the fixed list of units_supported. Missing value, non-finite numbers such as NaN or Infinity, missing unit fields, and any token that does not map to a supported unit fail with invalid_input and are not charged after the engine rejects the request. Identical inputs always yield identical JSON because the path is pure arithmetic with no randomness, no remote lookup, and no dependence on the wall clock, which makes the endpoint safe to pin in continuous-integration goldens and SDK contract tests. Large display sizes and fractional sub-pixel values share the same code path, so extreme magnitude pairs remain well-defined as long as IEEE double precision can represent the intermediate points product.
Browser use, API pricing, and everyday design workflows
Switch to the prepaid API when a design-system token pipeline, theme generator, email HTML renderer, PDF layout tool, accessibility checker, or documentation site must convert typographic sizes at scale under a stable KIT contract at $0.002 per successful item; validation failures that raise invalid_input do not consume balance after rejection. Pair this endpoint with general length converters when a product pipeline also needs millimeters or inches, or call it alone when search traffic is specifically for points to pixels, pt to px, and pica conversion at ninety-six DPI rather than a general unit switchboard.
Integration use cases
CSS and design-system tokens
Convert base font sizes from points in brand guidelines to CSS pixels (and back) so token JSON, Tailwind configs, and style sheets share one 96 DPI view without hand-written 4/3 factors.
Docs and layout pipelines
Convert typography sizes in documentation generators and accessibility checkers with a prepaid, deterministic API and clear invalid_input on unknown unit names.
Technical questions
How many pixels is one point at 96 DPI?
Exactly 4/3 CSS pixels (about 1.333… px) because 1 in = 96 px = 72 pt. Send value: 1, from: "pt", to: "px" to see it in the result field.