Law & accessibility

Distinguish font licenses for web, apps and print

Germany/EU, sources checked November 2026: assess the actual use and keep technical integrity separate from legal authorization.

A red glass Ä stands in front of glass, metal and embossed paper specimens labelled in German for web, app and print.

The brand typeface appears on a business card, runs on the website and is then expected to join a new application. Visually, that is one coherent identity. Licensing can nevertheless involve several different acts. Finished printed artwork, a font downloaded by a browser and a file distributed inside an application are not the same thing. The useful starting point is therefore the specific file, its source and the intended use rather than the family name alone.

This guide addresses project review in Germany within the EU legal context. Legal and source information was checked on November 9, 2026. The German Copyright Act consulted identifies its latest amendment as the law of May 26, 2026. This article does not determine international contract questions or the protectability of a particular typeface. Provider examples describe particular licensing models. The accompanying package checker performs a technical integrity check and explicitly makes no legal authorization decision.

Separate typeface design, font file and use

A typeface design is the visible shape of the characters. A font file contains data that software uses to display those characters. An exported picture does not necessarily contain the same reusable font data. This distinction already helps with an initial inventory: are you delivering finished artwork, or a resource another person can use to set new text? Those deliveries need separate consideration even when they produce a similar visual result.

Section 2 of the German Copyright Act links protected works to personal intellectual creation. It does not establish that every visible letterform is automatically protected or unprotected. Section 69a addresses specific requirements for computer programs. Do not equate the particular design, technical file and possible program protection without considering the actual subject matter.

Practical license review does not require replacing these questions with an improvised legal shortcut. First obtain the applicable terms and identify the planned use. An unexplained download becomes no more dependable because someone describes the typeface as ordinary or technically simple. Equally, a prominent manufacturer name does not establish one particular contractual restriction. Record which concrete rights or contract questions remain open and who is responsible for resolving them.

The authorized scope is the central question

Section 31 in the official consolidated Copyright Act addresses rights of use that may be limited in content, time or territory. Where uses are not individually specified, the purpose underlying the contract matters. For project administration, an invoice naming a font therefore does not automatically answer every subsequent use question. Examine the associated terms and the agreed scope rather than treating proof of payment as universal authorization.

Keep the order record, license and used files linked in an understandable way. Also identify the individual or organization receiving the permission. An agency, its client and another supplier are different parties. Whether they may exchange font files does not follow solely from working on the same design project. The permitted collaboration needs support in the applicable terms. This remains a separate question from whether the resulting visual output may be delivered.

Desktop license, web license and app license are useful commercial labels. Their detailed meaning is not established by the label alone. An offer may cover particular workstations, projects, domains or other boundaries. Read the definitions instead of assuming that a familiar label has a familiar scope. When asking the provider for clarification, describe the actual workflow rather than requesting a label without explaining the intended actions.

Create a use matrix before integration

Planned actionWhat actually travelsReview question
Create printed artworkA finished designDoes the permission cover that output?
Serve a webfontA font file sent to a browserIs this delivery route covered?
Publish an applicationA font inside the application packageIs bundling for this app covered?
Hand over editable workEditable document and possibly a font fileWho needs their own rights?
Provide a PDFA document with a particular form of embeddingWhich embedding conditions apply?
Generate documents automaticallyUse inside a server workflowIs that installation and processing covered?

This matrix is an editorial organization proposal, not a statutory list of license categories. Add the actual provider, relevant terms and responsible reviewer for every row. An unresolved row stays unresolved. Avoid a single green status for an entire font family when only one specific use has been assessed. Otherwise a later feature can easily be mistaken for something already covered by an earlier decision.

Document movement between rows as well. An exported advertising picture can later become part of an app without the font file being included. An editable template may require additional font resources. Both may be described informally as an app graphic. The matrix should identify the real technical and editorial action instead. That action can then be compared with the appropriate permission rather than with a project nickname.

Check open licenses against the particular package

The SIL Open Font License 1.1 grants broad use subject to conditions. Redistribution of font software involves copyright and license information, while modification can involve declared Reserved Font Names. Documents created with a font do not become OFL-licensed merely because of that use. Still inspect the specific package. A general license name does not replace its accompanying notices or the connection between those notices and your actual files.

The current OFL FAQ, version 1.1-update8 distinguishes embedding, distribution and modification. A WOFF conversion preserving specified data and metadata can differ from an altered character inventory. Do not decide from the extension alone. Record the source, processing and output of an optimization. Particular exceptions require actual review and do not constitute blanket permission for arbitrary conversion tools.

The public Source Sans license document in Adobe's repository provides a concrete provenance example. It identifies OFL 1.1 and the reserved name “Source”. It also illustrates why one manufacturer name does not imply uniform conditions. An open project and a subscription service from the same organization can operate differently. The program example below does not download or modify a real font from that repository.

Do not transfer terms between products

The Adobe Fonts licensing FAQ distinguishes finished outputs, editable client documents and application embedding. The subscription uses described there do not automatically permit distributing a font file inside a mobile or desktop app. Delivery to another editor also needs separate consideration. These statements concern the documented Adobe Fonts service and should not be generalized to every font associated with Adobe.

The separate Adobe webfont licensing guidance describes its hosting route and client project arrangements. Being technically able to download a file does not establish arbitrary self-hosting rights under that service. Determine which account and integration support the actual project before implementation. Switching the delivery route may require a new licensing assessment even when the visible text remains identical.

The Microsoft FAQ for Windows fonts distinguishes naming an available system font in CSS from copying a font onto a web server. Document embedding does not provide general app-bundling permission there either. Scope matters: that FAQ concerns the Windows fonts it describes. Files obtained elsewhere require their own applicable terms rather than assumptions imported from the Windows installation.

Make the client handover specific

Consider an explicitly fictional project producing a brochure, a website and later a desktop application. The agency initially creates the brochure. Without additional documentation, that fact does not determine whether the client may install the font, whether a web server may distribute a font file or whether the application may contain it. The project needs a separate supported entry for each expansion rather than an inherited approval.

A good handover first names the finished deliverables. It then separately identifies editable files and the resources required for further editing. Where a font file must not be transferred, it must not accidentally enter an automatically generated collection of project resources. That is both an organizational and a technical task. A note in the handover email does not repair an inappropriate package that was already assembled and delivered.

Identify responsibilities after project completion as well. Who maintains any required account? Who reviews another domain or application? Who retains the original evidence? Without these answers, a change of operator can separate the records from the actual product. The answers need not form an elaborate administrative system. They must correspond to the real organizations and the actual files rather than a generic agency checklist.

Build a compact evidence register

A register should connect at least the file, provenance, associated license evidence and planned use. Include a specific version or retrieval date. A changing homepage URL alone is an imprecise provenance record. Preserve the documents actually reviewed and identify the revision underlying a decision. Private ordering information belongs in the internal records, not automatically in public notices. Separate evidence needed for internal traceability from information required in the delivered package.

Keep three states distinct: documents available, technical association confirmed and use professionally assessed. Any of these can be missing independently. A package may contain the expected files while the proposed use remains unresolved. A use may have been assessed correctly while the wrong file enters the final build. This distinction exposes failures that a single “license present” field would conceal. It also indicates who needs to act next.

Cryptographic hashes support technical association. They help establish whether a file matches the documented revision. They do not establish that the original acquisition was lawful or that an adjacent text applies to the file. A hash is an integrity observation, not a provenance judgment. The initial professional association must be reviewed by other means. An automated hash update should therefore never silently replace the need to examine changed source material.

The complete technical checking function

The following Node module compares two explicitly identified files with their expected digests. It receives their contents as memory objects. It does not search the computer, inspect a client repository or fetch the source. Source URL validation only requires HTTPS without credentials or a fragment. A conforming address does not establish reachability, authenticity or sufficient licensing. That boundary remains present when every technical check succeeds.

import {createHash} from 'node:crypto';
const SHA = /^[a-f0-9]{64}$/;
const PATH = /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.[a-zA-Z0-9]+$/;
const KEYS = ['fontPath','fontSha256','noticePath','noticeSha256','sourceUrl'].sort();
export const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
export function auditEvidence(record, files) {
  if (!record || typeof record !== 'object' || Array.isArray(record) ||
      Object.keys(record).sort().join(',') !== KEYS.join(',') || !(files instanceof Map)) {
    throw new TypeError('Ungültiges Nachweisformat.');
  }
  if (!PATH.test(record.fontPath) || !PATH.test(record.noticePath) ||
      !SHA.test(record.fontSha256) || !SHA.test(record.noticeSha256)) throw new TypeError('Ungültige Pfade oder Hashes.');
  if (record.fontPath === record.noticePath) throw new TypeError('Schrift und Nachweis müssen getrennt sein.');
  let source;
  try { source = new URL(record.sourceUrl); } catch { throw new TypeError('Ungültige Quelle.'); }
  if (source.protocol !== 'https:' || source.username || source.password || source.hash) throw new TypeError('Ungültige Quelle.');
  const problems = [];
  for (const [pathKey, hashKey] of [['fontPath','fontSha256'],['noticePath','noticeSha256']]) {
    const bytes = files.get(record[pathKey]);
    if (!Buffer.isBuffer(bytes) || bytes.length === 0) problems.push({path:record[pathKey],reason:'missing_or_empty'});
    else if (sha256(bytes) !== record[hashKey]) problems.push({path:record[pathKey],reason:'hash_mismatch'});
  }
  return {evidenceMatches:problems.length === 0,legalAssessment:'not_evaluated',problems};
}

The permitted paths deliberately follow a simple pattern. Absolute paths and parent-directory traversal do not satisfy this example contract. The function does not inspect symbolic links or filesystem permissions because it opens no files. Any added filesystem adapter needs its own boundary review. A syntactically acceptable string does not by itself guarantee safe resolution inside a real release directory. Do not present this memory-based function as a general project filesystem scanner.

The file format is not analyzed either. The demonstration file is therefore explicitly called demo.bin. Its bytes are synthetic test text rather than a usable font. The notice is not an actual license grant. This boundary prevents the demonstration from appearing to authorize an invented typeface. Results describe matching or missing byte evidence only. The legal assessment field always remains not_evaluated, including in the successful technical case.

German-labelled explanation separates web delivery, app bundling and print from digest verification. Two executed cases show matching bytes and a missing notice. Legal assessment remains open in both.
Both results come from the executed synthetic-byte example. 47 checks concern technical integrity and the stated input boundaries. Matching files do not make the module assess a license or authorize use. Provenance, applicable terms and the specific intended action require independent review.

Read the executed counterexamples correctly

The actual run contains 47 successful conditions. Cases include matching bytes, missing or empty files, changed contents, invalid path forms and invalid digest strings. Both expected files can be missing at once; the checker must then report both problems. Another condition verifies that legal assessment remains open in the technically matching case. None of these conditions reads real font files or accesses an external account.

{
  "fixture_scope": "Fictional source URL, synthetic bytes, no actual font or granted license. Hash integrity only.",
  "record": {
    "fontPath": "fonts/demo.bin",
    "fontSha256": "c53322204d264f864c07865e8d0c85bbe3e1f85c67c7456ac76cf7ab94eb2d1a",
    "noticePath": "notices/demo.txt",
    "noticeSha256": "8efccb6c6c7946a05f59503a1b485f3ebafabf6f84cede79d6d288f190313a6a",
    "sourceUrl": "https://example.invalid/release/fictional"
  },
  "matchingResult": {
    "evidenceMatches": true,
    "legalAssessment": "not_evaluated",
    "problems": []
  },
  "missingNoticeResult": {
    "evidenceMatches": false,
    "legalAssessment": "not_evaluated",
    "problems": [
      {
        "path": "notices/demo.txt",
        "reason": "missing_or_empty"
      }
    ]
  }
}

The first result establishes agreement with the stored technical revision. The second reports a missing notice. That creates a specific work item: inspect and complete the package before proceeding with its proposed use. It does not automatically decide whether any particular act is lawful or unlawful. Even a perfectly matching package could rely on an incorrect original association. The independent professional review remains necessary precisely because technical equality cannot resolve that assumption.

Keep optimization and later changes traceable

A smaller font resource may improve loading. It may also lose characters or raise a different licensing question. Record the input file, tool, settings and output of each transformation. Retain the original and derivative separately. Alongside the applicable terms, check the languages and characters the product genuinely needs. A missing accent in a client's name is not merely cosmetic when the application is expected to represent that name correctly.

A version change requires more than leaving the file name unchanged. Compare the new evidence with the previous revision and update the technical association after review. Automatically replacing a digest without a professional record defeats the purpose. State which uses were reconsidered. A web package change says nothing by itself about the app version still being distributed or print files delivered previously. Those remain separate assets with their own histories.

Also preserve what was deliberately excluded. A package may contain only a finished illustration while the editing font remains outside it. Record that distinction so someone maintaining the project does not later “complete” the delivery by adding an unauthorized resource. Good records describe the intended absence as clearly as the included files. They should help the next person maintain the reviewed workflow rather than simply repeat the original export command.

A checklist before publication

Connect procurement, design and development during acceptance. Procurement may hold the order and contracting party. Design knows which styles the layout actually uses. Development knows which resources enter the shipped package. Bring those perspectives together before publication. Inspect the final artifact as well: an old build can retain an unused file while a revised layout may introduce a new style that has not reached the inventory.

A useful small-project sequence is to identify required resources, review provenance and proposed use, assemble the package with its notices and finally compare that exact package with the recorded revision. A discrepancy should return to the relevant step. Do not merely update the digest list to match an unintended change. Name a successful result accurately: files match the reviewed revision. That statement remains different from an automatic declaration that every proposed use is legally permitted.

  • Identify the specific font file and actual provenance.
  • Distinguish typeface design, software resource and finished output.
  • Record every intended use separately in the matrix.
  • Check licensee, duration and other applicable limits.
  • Separate self-hosting, app bundling and document embedding.
  • Consider modifications and any declared reserved names.
  • Associate necessary notices with the correct package.
  • Assign client handover and further editors explicitly.
  • Keep technical digest checks separate from legal assessment.
  • Revisit the evidence when a new use is introduced.

A dependable workflow starts with a specific file and ends with a specifically described use. A font family name, successful installation or matching hash cannot replace that connection. Separate provenance, package integrity and use assessment so a later expansion remains reviewable. This avoids an everyday mistake: assuming that a brand typeface already used somewhere may automatically be included in every subsequent medium. The review should follow the actual action, not the familiarity of its visual appearance.

Let’s move forward

What would you like to change?

An idea, a specific challenge or your next step with AI. We’re listening.

Let’s talk