Didot point converter
12 Didot points, one cicero, measure 4.512 mm. Convert between Didot points, ciceros, millimetres, centimetres, PostScript points, picas and inches, so a continental type specification lines up with a modern layout file. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Numeric size to convert
- 12
- Source unit
- dd
- Target unit
- mm
- Result
- 4.512
- From label
- Didot point
- To label
- millimeter
- Millimeters
- 4.512
A Didot point converter turns a European typographic size written in Didot points, ciceros, millimeters, or PostScript points into any other supported unit without leafing through print tables or rewriting layout formulas by hand.
Supported units and how the Didot conversion is computed
The converter accepts seven length and typography families under stable canonical codes: dd for the European Didot point equal to zero point three seven six millimeters by modern continental convention, cicero for twelve Didot points equal to four point five one two millimeters, mm for the millimeter, cm for the centimeter equal to ten millimeters, pt for the PostScript and DTP point equal to one seventy-second of the international inch, pc for the PostScript pica equal to twelve PostScript points, and in for the international inch of twenty-five point four millimeters.
Because the intermediate is always millimeters, 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. CSS pixels, device-pixel ratios, em and rem relative units, and historical royal-inch Didot definitions are intentionally out of scope so print and European typography workflows get predictable results under one clear millimeter-based convention that bridges continental and PostScript systems.
Everyday print and layout jobs
Use the free in-browser Didot point converter when you need a quick twelve-Didot to millimeter check, a cicero-to-PostScript-point print-to-DTP bridge, or a millimeter-to-Didot back-conversion while reading a European style guide, metal-type specimen, InDesign continental preset, or French and German typography 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.
What you can do with it
European print and metal-type specs
Convert Didot points and ciceros from continental type specimens and style guides into millimeters or PostScript points so modern DTP files match traditional measures.
Continental-to-DTP handoff
Bridge French and German Didot sizes into PostScript points and picas when building InDesign templates, PDF generators, and cross-border brand systems.
FAQ
How do I convert Didot points to millimeters?
The response includes result, the intermediate millimeters field, and a short formula line.
What is a cicero in this converter?
A cicero is twelve European Didot points, equal to 4.512 mm under the modern 0.376 mm Didot convention. Use from or to equal to "cicero" or "cc".
How does a Didot point differ from a PostScript point?
A Didot point (dd) is 0.376 mm. A PostScript point (pt) is 1/72 inch, about 0.3528 mm. This converter supports both so you can bridge European and DTP systems explicitly.
Is the Didot point converter free?
The browser tool runs free on your device.
Can I convert CSS pixels or em units?
No. Screen pixels, device pixel ratios and relative units such as em and rem are left out on purpose, as are historical royal-inch Didot values, so print measures follow one clear millimetre-based rule.
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/didot-point \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":12,"from":"dd","to":"mm"}'const res = await fetch("https://api.kit.forhosting.com/conv/didot-point", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 12,
"from": "dd",
"to": "mm"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/didot-point",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 12,
"from": "dd",
"to": "mm"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/didot-point", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":12,"from":"dd","to":"mm"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":12,"from":"dd","to":"mm"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/didot-point", 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": "dd",
"to": "mm"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.didot_point",
"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 and print pipelines need the same contract from servers and automation.
Supported units and how the Didot conversion is computed
Friendly aliases such as didot, didot point, cicero, cc, millimeter, centimetre, postscript point, pica, and inch 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 millimeters-per-unit factor for the source, then divides by the millimeters-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 millimeters quantity, the dimensionless factor from source to target, the fixed didot_mm field equal to zero point three seven six, a short formula line suitable for UI display, the method tag didot_mm_factors, 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-point values share the same code path, so extreme magnitude pairs remain well-defined as long as IEEE double precision can represent the intermediate millimeter product.
Browser use, API pricing, and everyday print workflows
Switch to the prepaid API when a typesetting pipeline, brand-guideline token generator, museum catalog, educational worksheet, PDF layout tool, or documentation site must convert European Didot 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 the Anglo-American points-to-pixels converter when a product also needs CSS pixels at ninety-six DPI, or call it alone when search traffic is specifically for Didot points, ciceros, and millimeter conversion rather than a general unit switchboard. Authors shipping design tools or chatbots can map the result, millimeters, didot_mm, and formula fields directly into cards that show both the number and the conversion path European printers, type designers, and layout engineers expect on paper.
Integration use cases
Docs and education pipelines
Convert Didot typography sizes in curriculum tools and documentation with a prepaid, deterministic API and clear invalid_input on unknown unit names.
Technical questions
What happens if I send an unknown unit?
The request fails with invalid_input. The error names the bad field and lists supported units (dd, cicero, mm, cm, pt, pc, in) so you can correct the call.