ForHosting KIT · Documents & PDF

Check PDF fonts embedded

A PDF can look correct on the computer that created it yet change when opened, printed, or processed somewhere else if one or more fonts are not embedded.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

This check accepts the font inventory produced by a PDF inspection tool, including an embedded flag for each entry, and returns a clear pass or fail summary. It also lists every font that needs attention, making preflight review easier to automate and simpler to explain.

Why font embedding matters for portable PDF files

A PDF normally describes both the page layout and the fonts used to draw its text. When a font program or an allowed subset is embedded, a viewer or printer has the information needed to reproduce those characters consistently. When it is missing, the receiving system may search for a locally installed substitute. That substitute can have different character shapes, widths, spacing, or language coverage. The result may be altered line breaks, clipped labels, missing symbols, or unexpected pagination even though the original file looked fine. Commercial printers therefore include font embedding in routine preflight checks, and teams that archive or exchange documents benefit from the same precaution. This capability turns the font inventory from an inspection utility into a small, deterministic compliance result. It does not inspect PDF bytes itself; instead, it evaluates the names and embedded flags you already obtained. That separation makes it useful in pipelines where another trusted tool extracts PDF metadata and this step applies a consistent acceptance rule.

How to supply the font list and read the result

Provide at least one font record. Every record must contain a non-empty name and a Boolean embedded value. Use true only when the inspection source explicitly reports that the font is embedded; use false when it reports that the font is absent from the PDF. The check preserves the supplied order, counts all records, counts the embedded and unembedded entries, and returns the unembedded names as a separate list. The all_embedded value is true only when every supplied flag is true. Subset prefixes such as six uppercase letters followed by a plus sign are kept as part of the name because they can help a prepress operator match the result to the source report. Duplicate records are also retained and counted rather than silently merged, since they may describe separate font resources in the document. An empty list is rejected because it cannot distinguish a genuinely font-free document from a failed or incomplete extraction step. Malformed names and non-Boolean flags are rejected for the same reason: guessing would make a preflight result less trustworthy.

Use the check as one part of a complete preflight

Run this check immediately after extracting a PDF font inventory and before approving the document for print, distribution, or long-term storage. If all_embedded is true, the supplied inventory passes this specific rule. If it is false, use not_embedded_fonts to create a focused remediation report. The document author can then embed the original fonts during export, choose fonts whose licenses permit embedding, convert specialized artwork text to outlines when appropriate, or regenerate the PDF with a suitable archival or print preset. After correction, extract a fresh inventory and run the check again rather than editing the flags manually. Remember that font embedding is only one preflight dimension. A production workflow may also need to examine color spaces, image resolution, bleed, page boxes, transparency, encryption, and the PDF standard claimed by the file. This capability deliberately does not infer whether a font license permits embedding, whether every glyph is present, or whether outlined text remains searchable. Its narrow output makes the result predictable, easy to log, and straightforward to combine with broader quality controls.

What you can do with it

Preflight a print submission

Reject a supplied document when its extracted font inventory contains any resource that is not embedded.

Protect document portability

Check reports, manuals, and forms before distribution so recipients are less likely to see substituted typography.

Add a release quality gate

Convert font metadata from an existing PDF inspection stage into a deterministic pass or fail result for automation.

FAQ

Does this capability open or parse the PDF file?

No. It checks a font list and embedded flags supplied by a PDF inspection or preflight tool.

What happens when the font list is empty?

The request fails with an invalid input error because an empty extraction cannot support a reliable embedding conclusion.

Are subset font names treated as embedded automatically?

No. Names are labels only. The result follows the explicit Boolean embedded flag supplied for each record.

Are duplicate font names removed?

No. Every record is counted and every unembedded occurrence is retained in input order.

Does an all-embedded result guarantee that the PDF is print-ready?

No. It confirms only the supplied font embedding flags. Other print checks may still be required.

What does the API request cost?

Each request costs $0.002. The browser version uses the same deterministic checking logic.

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/pdf/font-embedding-check

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/pdf/font-embedding-check \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"fonts":[{"name":"Helvetica","embedded":false},{"name":"ABCDEE+SourceSansPro-Regular","embedded":true},{"name":"TimesNewRomanPSMT","embedded":false}]}'

const res = await fetch("https://api.kit.forhosting.com/pdf/font-embedding-check", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "fonts": [
      {
        "name": "Helvetica",
        "embedded": false
      },
      {
        "name": "ABCDEE+SourceSansPro-Regular",
        "embedded": true
      },
      {
        "name": "TimesNewRomanPSMT",
        "embedded": false
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/pdf/font-embedding-check",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "fonts": [
        {
            "name": "Helvetica",
            "embedded": false
        },
        {
            "name": "ABCDEE+SourceSansPro-Regular",
            "embedded": true
        },
        {
            "name": "TimesNewRomanPSMT",
            "embedded": false
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/pdf/font-embedding-check", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"fonts":[{"name":"Helvetica","embedded":false},{"name":"ABCDEE+SourceSansPro-Regular","embedded":true},{"name":"TimesNewRomanPSMT","embedded":false}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"fonts":[{"name":"Helvetica","embedded":false},{"name":"ABCDEE+SourceSansPro-Regular","embedded":true},{"name":"TimesNewRomanPSMT","embedded":false}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/pdf/font-embedding-check", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "fonts": [
    {
      "name": "Helvetica",
      "embedded": false
    },
    {
      "name": "ABCDEE+SourceSansPro-Regular",
      "embedded": true
    },
    {
      "name": "TimesNewRomanPSMT",
      "embedded": false
    }
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "pdf.font_embedding_check",
  "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.

Limits

max_items 10000

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.

Read the full KIT documentation →