ForHosting KIT · Developer Utilities

Cologne phonetics encoder

Müller, Mueller and Muller all get the code 657, and Schmidt and Schmied share 862, so spelling variants of a German name land together. Use it to spot likely duplicates in registries, customer lists and family trees. 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

Text: Müller

You get

Code: 657
Length: 3
Normalized: MULLER
Letter count: 6

Cologne phonetics, known in German as Kölner Phonetik, maps surnames and given names to a short digit string so variants that sound alike share one key. Civil registries, CRM deduplication jobs, and genealogy tools use it when Müller must match Mueller, or Schneider must cluster with Schnyder without a full phonetic model. You get a stable code field plus the normalized letter sequence so you can audit why two records collided.

What Cologne phonetics encodes and why names collide

Cologne phonetics was designed for German-language civil lists where spelling drift is common: umlauts written as digraphs, silent H, soft C versus hard C, and X carrying two codes. The algorithm does not claim IPA accuracy; it aims for a compact, deterministic key that groups names people pronounce similarly. Letters A, E, I, J, O, U, and Y map to zero and then disappear unless they open the code.

H is ignored entirely. Consonants map to one through eight with context rules—for example P before H becomes three like F, D or T before C, S, or Z becomes eight like S, and X becomes forty-eight unless it follows C, K, or Q. After the letter pass, consecutive identical digits collapse so Schmidt and Schmied both reduce to eight-six-two, and remaining zeros except a leading zero are stripped.

That is why Müller, Mueller, and Muller all yield six-five-seven, and why Mayer, Meier, Maier, and Mayr share six-seven. Genealogy and master-data teams treat equal codes as a candidate match, not proof of identity: middle names, married names, and transcription errors still need human or secondary checks. Use the returned normalized field to see which letters survived stripping of spaces, hyphens, and digits before encoding.

What you can enter and what you get back

Extremely long pastes above the published character cap also fail so edge workers stay predictable. Non-letter characters never appear in normalized: punctuation, spaces, and digits are dropped before encoding. If no letter remains—for example text equal to 12345 or only symbols—the task fails with a message that the input is empty or non-alphabetic and asks for at least one letter.

Those failures are not billed. There is no decode direction: Cologne codes are many-to-one and lossy, so reverse lookup would need an external name dictionary you maintain yourself. Example: text Müller yields code 657 with normalized MULLER; text Schmidt yields 862; text Fischer yields 387.

Where Cologne phonetics helps in practice

Customer data platforms use Cologne phonetics during onboarding merge-and-purge so German surnames typed with and without umlauts do not create duplicate accounts. Public-sector migration scripts attach a cologne code column next to soundex or metaphone columns when comparing multi-source citizen extracts. Classroom modules that teach name matching need a deterministic oracle that rejects empty paste instead of returning an empty string that a buggy grader might treat as a match-all.

Prefer this encoder when the corpus is German or Central European; for English-only radio spelling use a NATO alphabet tool, and for English-oriented fuzzy match compare soundex or metaphone landings rather than forcing Cologne on Anglo names. Keep requests to single names or short tokens, store the code beside the original spelling, and re-encode after cleaning titles such as Dr or Frau in your own pipeline if you want title-free keys.

What you can do with it

CRM and customer deduplication

Attach a Cologne code to each German surname so Müller and Mueller cluster before human review of possible duplicate accounts.

Genealogy and civil-list indexing

Index historical person rows by Kölner Phonetik so search for Schneider also surfaces close spelling variants without a full-text model.

ETL match keys for German extracts

Add a deterministic cologne column in migration jobs next to other phonetic keys for multi-source citizen or employee files.

FAQ

What is Cologne phonetics (Kölner Phonetik)?

A German name-matching algorithm that maps a word to a short digit string using fixed letter rules, context for C, D, T, P, and X, then collapses repeated digits and interior zeros.

Why do Müller and Mueller get the same code?

Umlauts fold to base vowels (Ü→U), vowels map to zero and are stripped except a leading zero, and the remaining consonant codes match—so both normalize toward MULLER and code 657.

What happens on empty or digit-only input?

At least one alphabetic character (including German umlauts or ß) is required; empty, whitespace-only, and non-alphabetic strings are rejected and not billed.

Can I decode a Cologne code back to a name?

No. The mapping is lossy and many-to-one. This encoder only produces the digit code; reverse lookup needs your own name dictionary.

Does the same Cologne code mean two records are the same person?

No. Equal codes only mark a candidate match. Middle names, married names and transcription errors still need a human look or a second check, such as the same region or a similar birth year.

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/enc/cologne-phonetic

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/enc/cologne-phonetic \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Müller"}'

const res = await fetch("https://api.kit.forhosting.com/enc/cologne-phonetic", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "Müller"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/enc/cologne-phonetic",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "Müller"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/cologne-phonetic", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"Müller"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"Müller"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/cologne-phonetic", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "text": "Müller"
}

Example response

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

This Cologne phonetics encoder applies the classic Postel rules in a pure Worker: uppercase and fold umlauts, map each letter with neighbor context, collapse consecutive identical digits, and drop interior zeros. Empty strings and digit-only paste fail with invalid_input instead of inventing a hollow zero-length success.

Input contract, response fields, and invalid_input cases

POST a JSON object with required string text (aliases input, value, name, or s). Trim is applied; pure whitespace and missing fields fail with invalid_input naming the problem. On success the body echoes text, returns code as the digit string, length as the number of digits, normalized as the uppercase A–Z sequence after umlaut folding (Ä Ö Ü to A O U, ß to SS), and letter_count for that sequence. Pair code equality checks with your own thresholds (same postal region, similar birth year) when building a match score; this endpoint only computes the phonetic key.

Technical questions

What does the Cologne phonetics encoder 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