ROT47 encoder and decoder
Hello becomes w6==@ and the same step brings it back: every printable character from the exclamation mark to the tilde moves 47 places in a ring of 94, while spaces and accented text stay as they are. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello World!
- Result
- w6==@ (@C=5P
- Encoding
- rot47
- Input length
- 12
- Output length
- 12
This ROT47 encoder applies a classic printable-ASCII Caesar cipher that shifts every character from exclamation mark through tilde by forty-seven places in a ninety-four character ring. Spaces, tabs, newlines, and non-ASCII Unicode pass through unchanged so multi-line notes and mixed scripts stay readable around the scrambled core.
What ROT47 is and what this tool returns
ROT47 is a substitution cipher over the ninety-four printable ASCII characters from code thirty-three through one hundred twenty-six. Each of those symbols is mapped to the symbol forty-seven steps ahead, wrapping around the ring with modular arithmetic: the new code is thirty-three plus the remainder of code minus thirty-three plus forty-seven when divided by ninety-four. Letters, digits, and punctuation all move together, which makes ROT47 denser than letter-only ROT13 and better at scrambling mixed tokens such as passwords, config snippets, and short challenge strings.
Characters outside that range never change: space keeps lines readable, and emoji or accented text survives for mixed-language demos. This page always uses that exact modular rule with no optional shift parameter and no alphabet tables that could drift between languages.
Where ROT47 helps with puzzles and demos
Developers and educators meet ROT47 in capture-the-flag warm-ups, textbook chapters on classical ciphers, and lightweight client-side obfuscation that must reverse with one function instead of a key schedule. Frontend teams can scramble sample credentials or token-shaped strings for screenshots without inventing a custom alphabet. Backend services encode short configuration fragments for puzzle APIs or teaching sandboxes where students must apply the same shift to unlock the next step.
Quality engineers generate deterministic encode pairs for contract tests so a middleware that claims ROT47 support cannot silently switch to ROT13 or a different offset. Contest organizers precompute answer keys for modest ASCII phrases without trusting opaque web toys that change spacing rules. Product and education tools use the transform when a learner pastes ciphertext and the UI must show the recovered plaintext under the involution property.
Pair it with other encoding helpers when you are building a small lab of free, deterministic text tools.
What you can do with it
CTF and cipher warm-ups
Obfuscate and restore printable ASCII phrases with one reversible step for puzzles, classrooms, and capture-the-flag practice.
Reversible demo obfuscation
Hide sample tokens or config snippets in docs and screenshots, then recover them with the same ROT47 call.
FAQ
What does the ROT47 encoder cost?
It is free in your browser on this page.
How do I decode ROT47?
Apply the same transform again. ROT47 is an involution: encode and decode are identical operations on the printable ASCII ring.
Which characters are shifted?
Printable ASCII from ! through ~ (codes 33–126). Spaces, control characters, and non-ASCII Unicode pass through unchanged.
Is the result deterministic?
Yes. The same text always produces the same result with no network, randomness, or date-dependent behavior.
How is ROT47 different from ROT13?
ROT13 only moves letters, so digits and symbols stay readable. ROT47 moves all 94 printable ASCII characters, including digits and punctuation, which scrambles mixed strings such as codes or sample passwords much more thoroughly.
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/rot47 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello World!"}'const res = await fetch("https://api.kit.forhosting.com/enc/rot47", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello World!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/rot47",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello World!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/rot47", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello World!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello World!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/rot47", 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 World!"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.rot47",
"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
Because forty-seven is half of that ring size, the same operation both obfuscates and restores text: feed plain text once to hide it, feed the ciphertext again to recover the original. Common checks include Hello World becoming w6==@ (@C=5P and that string decoding back to Hello World under the same request. Use it free in the browser for CTF warm-ups, reversible obfuscation demos, and puzzle worksheets, or call the API at $0.002 per successful request when pipelines need reproducible ROT47 transforms in CI and backend services.
What ROT47 is and what this tool returns
The JSON response includes result for the transformed string, encoding fixed to rot47, input_length and output_length which match because ROT47 is length-preserving, shifted_chars counting how many code units fell inside the printable ring, and a formula string that restates the modular mapping for documentation and tests. There is no streaming path and no silent fallback to ROT13: either you supply non-empty text and receive a full transform, or the request fails with invalid_input. If you need letter-only rotation, URL-safe Base64, or Morse, use those dedicated endpoints; this landing answers only the ROT47 printable-ASCII contract that puzzle books and lightweight obfuscation guides already describe.
How text is read and how results stay reproducible
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. The string must be present and non-empty; missing fields, non-string types, and the empty string all raise invalid_input with a clear message so a blank form does not look like a successful no-op. Every code unit is processed independently with the fixed modular map, so applying the transform twice always yields the original payload when every character lives inside or outside the ring consistently. 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 the ninety-four character ring yourself. Invalid inputs return invalid_input and are not charged, which keeps validation cheap while successful transforms remain a fixed item price. Length fields and the shifted_chars counter help tests verify that spaces were preserved and that only printable ASCII moved, without re-deriving the ring arithmetic in every assertion.
Where ROT47 fits in puzzles, demos, and test fixtures
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 classroom demo to an automated pipeline without changing the transformed result.
Integration use cases
Deterministic CI fixtures
Generate reproducible ROT47 strings for unit tests, golden files, and contract checks across services.
Technical questions
What happens on empty input?
Empty or missing text fails with invalid_input and is not charged. Provide a non-empty string.