Wabun Morse code translator
こんにちは becomes ---- .-.-. -.-. ..-. -...: each kana mora gets its Wabun telegraph code, with spaces between letters and a slash between words. Voiced syllables such as が become the base code plus a dakuten mark, and decoding turns codes back into hiragana. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- こんにちは
- Calculation mode
- Encode
- Result
- ---- .-.-. -.-. ..-. -...
- Encoding
- wabun
- Input length
- 5
- Output length
- 25
This Wabun Morse code translator converts Japanese kana into classic Wabun telegraph codes and decodes those dot–dash sequences back into readable hiragana using a fixed, deterministic alphabet. Encode mode accepts hiragana and katakana (fullwidth or halfwidth), expands voiced and semi-voiced syllables into a base mora plus a dakuten or handakuten token, separates letters with a single space, and separates words with a slash so multi-word phrases stay unambiguous. Decode mode reverses the process: it reads only dots, dashes, spaces, and slash word separators, looks up every token in the public Wabun table, recombines diacritic marks onto the previous mora when possible, and fails clearly when a symbol or code is unknown.
What Wabun code is and what this tool returns
Wabun code is the Japanese-language Morse system in which each symbol represents a kana mora rather than a Latin letter. Encode mode folds katakana and halfwidth forms into the same tables as hiragana, expands が into the code for か plus the dakuten token, joins letter codes with one space, and joins words with space-slash-space so a human or machine can tell word boundaries without timing audio.
Decode mode accepts the same textual convention, also tolerating flexible spacing around the slash, rebuilds hiragana, and recombines a following dakuten or handakuten onto a compatible base when the table allows. If you need International Morse for Latin text, audio tone generation, or light-flash timing, use a specialized tool; this landing is only for the kana Wabun encode and decode contract that teachers, radio students, and test authors share.
Where a Wabun translator fits in learning, radio, and tests
Students meet Wabun when they study Japanese radio procedures, prepare for amateur license material that still mentions kana Morse, or solve classroom drills that require converting short phrases both ways without paper charts. Amateur radio operators use a text encoder to check practice phrases before sending them by key or software keyer, and a decoder to verify copy after a session that mixed international and Wabun segments.
Puzzle designers and game authors generate deterministic kana Morse riddles for escape rooms and CTF-style challenges where the same clue must always encode the same way. Pair it with the International Morse translator when a lab needs both Latin and kana Morse under the same deterministic house rules.
What you can do with it
Radio and exam practice
Encode study phrases in kana and decode practice copy for Japanese Morse drills without a paper Wabun chart.
Puzzles and classroom demos
Generate deterministic Wabun clues for escape rooms, CTFs, and live lessons with a shared word-separator rule.
FAQ
What does the Wabun Morse code translator cost?
It is free in your browser on this page.
What characters are supported?
Hiragana and katakana (including halfwidth), small kana folded to full size, long vowel mark ー, dakuten and handakuten (as separate codes or precomposed voiced forms), Japanese comma and period, and parentheses.
How are words and diacritics represented?
Letters are separated by a single space. Words are separated by space-slash-space ( / ). Voiced and semi-voiced kana encode as the base mora code followed by the dakuten (..) or handakuten (..--.) token.
Is the result deterministic?
Yes. The same text and mode always produce the same result with no network, randomness, or date-dependent behavior.
Why do っ and ゃ come back as full-size kana?
Small kana such as っ and ゃ share the telegraph codes of their full-size forms, as in historical practice. Decoding cannot tell them apart, so check those spots against the context of the message.
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/enc/japanese-wabun \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"こんにちは"}'const res = await fetch("https://api.kit.forhosting.com/enc/japanese-wabun", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "こんにちは"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/japanese-wabun",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "こんにちは"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/japanese-wabun", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"こんにちは"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"こんにちは"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/japanese-wabun", 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": "こんにちは"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.japanese_wabun",
"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 engine never calls a network, never samples randomness, and never depends on the calendar clock, so the same input and mode always produce the same result in the browser and through the API. Typical checks include encoding こんにちは to five letter codes, decoding that string back to the same kana, and rejecting Latin or kanji characters with invalid_input that names the unmapped symbols. Use it free on this page for radio practice, puzzle answers, and classroom demos, or call the API at $0.002 per successful request when you need reproducible Wabun transforms in CI and backend services.
What Wabun code is and what this tool returns
The JSON response always includes result for the transformed string, mode echoing encode or decode, encoding fixed to wabun, and input_length plus output_length so automated tests can assert sizes without re-parsing the payload. There is no silent skip of unknown characters and no private extension table: either every symbol maps cleanly or the request fails with invalid_input that reports the unmapped character or Morse token by name.
How text and mode are read and how results stay reproducible
Encode trims outer whitespace only for word-splitting semantics, treats internal whitespace runs as word separators, and rejects any character that is not in the supported Wabun set with a message that lists the unmapped symbols. Decode rejects any character outside the set of dots, dashes, spaces, and slash, rejects empty or malformed tokens, and rejects Morse sequences that do not appear in the reverse table, again naming the undecodable token. Small kana such as っ and ゃ share the telegraph codes of their full-size counterparts, matching historical practice that did not assign a separate sokuon pattern. The preferred payload field is text, with aliases input, value, s, and message so forms, query strings, and SDK clients can reuse the same contract without renaming columns. Mode defaults to encode and accepts decode explicitly; aliases op, direction, and action map to the same switch for scripts that already use those names. Because every branch is pure table lookup and string assembly, two clients with the same text and mode receive byte-identical results across Worker versions as long as the alphabet stays fixed. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing Wabun tables yourself. Invalid inputs return invalid_input and are not charged, which keeps exploratory validation cheap while successful transforms remain a fixed item price at $0.002 for API callers.
Where a Wabun translator fits in learning, radio, and tests
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a whiteboard demo to an automated pipeline without changing the encoded result.
Integration use cases
CI and golden fixtures
Assert encode and decode pairs in automated tests so separators and dakuten tokens never drift silently.
Technical questions
What modes are supported?
mode=encode (default) turns Japanese kana into Wabun Morse. mode=decode turns a Wabun string of dots, dashes, spaces, and / back into hiragana.