Braille translator
Type “Hello” and get ⠠⠓⠑⠇⠇⠕: a capital sign followed by five letter cells, ready to paste into a document without any special font. It also reads Braille back into text and stops at any cell it does not recognize. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello
- Calculation mode
- Encode
- Result
- ⠠⠓⠑⠇⠇⠕
- Length
- 6
- Input chars
- 5
- Grade
- 1
Braille is a tactile writing system of raised dots that lets readers feel letters, numbers, and punctuation with their fingertips. On screens and in documents, those same six-dot cells are stored as Unicode Braille Patterns from U+2800 through U+28FF, so you can copy, paste, search, and print digital Braille without a special font. This capability implements English Grade 1 Braille end to end: encode mode turns plain Latin text into a string of Unicode Braille characters with capital-letter and number indicators; decode mode reads Braille cells back into ordinary text and fails immediately when it meets an unmapped cell so bad paste jobs never silently corrupt meaning.
How Grade 1 Braille maps letters, digits, and indicators
English Grade 1 Braille assigns each lowercase letter a fixed six-dot pattern. Dot positions are numbered one through six in two columns of three, and Unicode encodes those dots as the low six bits of a code point starting at U+2800. Letter a is a single raised dot in position one, b uses dots one and two, and so on through z, including the distinctive w pattern that does not follow the same three-row extension as the other letters.
When you need an uppercase letter, Grade 1 places a capital indicator cell made of only dot six immediately before the letter cell; this capability applies that sign to every capital character so Hello becomes the capital sign plus h, then e, l, l, o. Numbers use a number indicator built from dots three, four, five, and six, after which the letter cells for a through j stand for digits one through nine and zero until a space or non-digit letter ends number mode.
Common punctuation has single-cell mappings: comma, semicolon, colon, period, exclamation mark, question mark, apostrophe, hyphen, straight quotation marks, and parentheses. Spaces stay ordinary space characters in the encoded string for readability, and blank Braille cells are also accepted as spaces when decoding.
Where Braille translation shows up in real work
Accessibility teams embedding Braille samples in documentation, style guides, and training materials need a reliable text-to-Braille path that produces copy-pasteable Unicode cells rather than images. Education platforms teaching Grade 1 reading assign letter drills, capital indicators, and number mode exercises; a single trusted oracle that encodes and decodes without Grade 2 contractions keeps answer keys aligned with beginner curricula. Engineers building inclusive product copy, museum labels, or wayfinding content often want a quick round-trip check before sending files to embossers or refreshable Braille displays.
Support desks paste Braille strings from tickets and need strict rejection of unknown cells instead of silent gaps that would mislead a reader. Curriculum authors prefer a dedicated Braille translator landing rather than burying the feature under a generic Unicode code-point converter, because search intent and the capital or number indicator rules are different problems.
If you need literary Grade 2 contractions, full Unified English Braille state machines, eight-dot computer Braille for arbitrary binary, or speech synthesis, treat those as separate search intents and landings rather than overloading this Grade 1 Braille translator page.
What you can do with it
Accessibility docs and training samples
Generate Unicode Braille snippets for style guides, onboarding materials, and inclusive design reviews without relying on image-only Braille art.
Grade 1 classroom drills and answer keys
Encode letter, capital, and number exercises, then decode student Braille submissions against a deterministic Grade 1 map for auto-grading.
FAQ
What kind of Braille does this translator use?
English Grade 1 Braille expressed as Unicode Braille Patterns (U+2800–U+28FF). It maps letters, digits with a number indicator, capitals with a capital indicator, space, and common punctuation—without Grade 2 contractions.
What happens on an unmapped Braille cell?
The product never silently drops or replaces unknown cells.
How are capital letters and numbers encoded?
Each uppercase letter is preceded by the capital indicator (dot 6, ⠠). A run of digits is preceded by the number indicator (⠼), after which a–j cells mean 1–9 and 0 until space or a non-digit letter ends number mode.
Is this the same as a Unicode code point converter?
No. A code point converter shows U+XXXX values for any character. This page specifically translates between readable text and Grade 1 Braille cells with indicator rules—different search intent and different rules.
What does it cost?
The browser tool is free and runs locally.
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/braille \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/braille", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/braille",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/braille", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/braille", 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": "Hello"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.braille",
"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
How Grade 1 Braille maps letters, digits, and indicators
The entire pipeline is deterministic table lookup with no network calls, no random seeds, and no wall-clock timestamps, so identical inputs always produce identical JSON. Characters outside the supported Grade 1 set fail on encode; Braille cells outside the recognized map fail on decode with a clear invalid_input message naming the position and code point.
What you send and what you get back
Send a required string field named text and an optional mode field set to encode or decode. Encode mode treats text as plain content and returns a result string of Unicode Braille Patterns plus spaces. Decode mode treats text as Braille, accepts ordinary whitespace and blank cells as spaces, applies capital and number indicators, and returns the recovered plain string in result. Both directions echo mode, the original text, result, a length field counting Unicode scalar values in the primary output, grade set to one, a script label naming Unicode Braille Patterns, and a short standard reference string so clients can assert which profile they hit. Classic checks include encoding Hello to the capital indicator plus the five letter cells for h e l l o, encoding a number such as forty-two with a leading number sign, and decoding a known Braille phrase back to readable text. When mode is omitted, encode is the default so a single payload still does useful work. Encode also reports input_chars; decode reports input_cells. Missing text, non-string objects, unsupported mode values, strings longer than the documented maximum, unmapped plain characters on encode, non-Braille symbols on decode, or Braille cells that exist in the Unicode block but are not part of this Grade 1 map all fail with invalid_input and a clear English message. Validation failures do not consume prepaid balance. Pricing for successful API calls is the published base of $0.002 per item.
Where Braille translation shows up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Round-trip fixtures for inclusive product copy
Build CI goldens that convert product strings to Braille and back so embosser-ready text stays synchronized with the print source.