Keyboard shift cipher
With an offset of one, hello becomes jraap: each letter slides one key to the right on its own QWERTY row, and the l wraps around to the a. The same offset in decrypt mode brings hello back. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- hello
- Offset
- 1
- Calculation mode
- Encrypt
- Result
- jraap
- Length
- 5
- Letters shifted
- 5
- Layout
- qwerty
A keyboard shift cipher does not rotate letters along the alphabet the way a Caesar cipher does. Instead it moves each character to a neighboring key on a physical QWERTY layout: with offset one in encrypt mode, Q becomes W, W becomes E, A becomes S, and so on along the same row. Decryption walks the opposite direction so a known offset always recovers the original message when every character was a supported letter or space. This capability implements that adjacent-key transform with a configurable integer offset and an encrypt or decrypt mode.
How a QWERTY keyboard shift moves letters
The United States QWERTY letter grid is treated as three independent rows: the top letter row qwertyuiop, the home row asdfghjkl, and the bottom row zxcvbnm. Encryption moves each letter a fixed number of keys to the right on its own row; decryption moves the same distance to the left. The step count is the integer offset you supply.
Movement wraps within the row only: the letter after P is Q again, after L is A, and after M is Z, so every alphabetic character always lands on another letter of the same physical row. Case is preserved so an uppercase H with offset one becomes uppercase J while a lowercase h becomes j. Spaces are copied unchanged so multi-word phrases keep their shape.
Digits, punctuation, emoji, and letters outside the basic Latin block are not on the supported letter map; the engine stops immediately with an unsupported-key error rather than inventing a neighbor. Mathematically the transform is modular arithmetic on the row index: find the character’s position on its row, add or subtract the offset modulo the row length, and map back to a character of the same case. Offset zero is the identity map; offset eleven on a ten-key row equals offset one.
There is no network call, no random seed, and no wall-clock timestamp in the path. This page implements same-row QWERTY adjacency only—not Caesar alphabet rotation, not a multi-row diagonal walk, and not strong encryption.
Where keyboard shift ciphers show up in real work
Introductory cryptography and keyboard-layout puzzles often ask students to scramble a message by sliding fingers one key sideways instead of counting alphabet positions; a single trusted oracle that encrypts and decrypts with an explicit integer offset speeds homework demos and auto-graders. Capture-the-flag warm-ups and escape-room props sometimes hide QWERTY-shifted phrases on notes or images, and solvers want a fast, predictable adjacent-key tool rather than a general cryptanalysis suite.
Support and content teams may lightly obfuscate spoilers or quiz answers with a trivial keyboard slide and need the reverse path without installing a language-specific library. If you need classical Caesar alphabet rotation, Vigenère polyalphabetic keys, Base64 encoding, or strong authenticated encryption, treat those as separate search intents and landings rather than overloading this QWERTY adjacent-key page.
What you can do with it
Classroom QWERTY adjacency demos
Encrypt and decrypt sample words with a known integer offset so students see same-row keyboard neighbors instead of alphabet math.
Puzzle and CTF keyboard shifts
Apply or reverse a fixed adjacent-key slide on challenge strings without writing a one-off script for every problem set.
FAQ
What is a keyboard shift cipher?
A substitution that moves each letter to a neighboring key on a QWERTY row by a fixed integer offset, instead of rotating along the alphabet like Caesar.
How do I decrypt text?
Set mode to decrypt with the same integer offset used to encrypt. That shifts each letter left on its row and recovers the original when only letters and spaces were present.
Does the shift wrap at the end of a row?
Yes. Movement is modular within the same QWERTY row, so P with offset one becomes Q, and L with offset one becomes A.
What does it cost?
The browser tool is free and runs locally.
Are capital letters and spaces kept?
Yes. Each letter keeps its case, so an uppercase H with an offset of one becomes J and a lowercase h becomes j. Spaces are copied unchanged, so a phrase of several words keeps its shape.
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/keyboard-shift \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"hello","offset":1}'const res = await fetch("https://api.kit.forhosting.com/enc/keyboard-shift", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "hello",
"offset": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/keyboard-shift",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "hello",
"offset": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/keyboard-shift", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"hello","offset":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"hello","offset":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/keyboard-shift", 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",
"offset": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.keyboard_shift",
"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
Only Latin A through Z are shifted, case is preserved, spaces stay put, and any digit, punctuation mark, or other symbol is rejected as an unsupported key with a clear invalid_input error.
How a QWERTY keyboard shift moves letters
Because every step is integer arithmetic with a fixed layout table, the cipher is fully deterministic: identical text, offset, and mode always produce identical JSON.
What you send and what you get back
Send a required string field named text, a required integer field named offset, and an optional mode field set to encrypt or decrypt. Encrypt mode shifts letters right by offset on the QWERTY row; decrypt mode shifts them left by the same absolute distance, which reverses a prior encrypt with that offset. Classic checks include encrypting hello with offset one to jraap (h→j, e→r, l→a with row wrap, o→p); decrypting that ciphertext with the same offset recovers hello; and confirming that hello! fails because the exclamation mark is an unsupported key. When mode is omitted, encrypt is the default so a minimal payload still does useful work. On success the response echoes mode, the original text, the integer offset you supplied, the transformed result string, length of that result, letters_shifted as a count of how many alphabetic characters moved, plus layout, rows, and cipher labels for clients that assert the profile they hit. Missing text, missing offset, non-string objects for text, unsupported mode values, strings longer than the documented maximum, non-integer offsets including floating values such as one point five, and any character that is not a Latin letter or space—punctuation, digits, symbols—fail with invalid_input and a clear English message naming the unsupported key when relevant. Validation failures do not consume prepaid balance. Pricing for successful API calls is the published base of $0.002 per item.
Where keyboard shift ciphers show 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
Lightweight spoiler obfuscation
Slide quiz answers or labels sideways on QWERTY and decrypt them later with the same contract in browser or API.
Technical questions
What counts as an unsupported key?
Any character that is not a Latin letter A–Z/a–z or a space—digits, punctuation, emoji, and accented letters fail with invalid_input and are not charged.