Scramble word letters
«generation» with the seed «kit-2026» always becomes «gateeonrin»: the first and last letters stay, the 8 inside letters are shuffled, and the same seed gives the same result anywhere. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Word
- generation
- Seed
- kit-2026
- Scrambled
- gateeonrin
- Letters
- 10
Because the shuffle is driven by a deterministic seeded algorithm rather than randomness, the same word with the same seed always produces exactly the same scrambled word — on our servers, in your browser, and in any other environment. Words with fewer than four letters are rejected with a clear error, since they have no interior letters to shuffle.
Why scrambled words stay readable
A well-known observation in popular linguistics says that readers can often still understand a word when its middle letters are jumbled, as long as the first and last letters stay in place, because recognition leans heavily on the overall shape of the word and its boundary letters. This tool performs exactly that transformation: it keeps the first and last letters fixed and shuffles only the letters between them. It does not promise that the result will be readable; it simply performs the shuffle. Words with fewer than four letters are rejected, since they have no interior letters to shuffle.
The same seed, the same scramble
Most scramblers draw a new random answer every time, which is fine for a toy but useless when you need to repeat a result. Here the seed is part of what you type: the same word with the same seed always produces exactly the same scramble, in your browser or anywhere else, and a different seed produces a different shuffle. That lets you build word puzzles whose answers can be regenerated later, give two players in a game the identical scramble, or show a class how interior scrambling works with an example that never changes. The result also reports the letter count and whether the word actually changed.
Deterministic by design: the seed is the contract
Most scramblers call a random number generator and give you a different answer every time. That is fine for a toy, but useless the moment you need reproducibility: a test that asserts on the output, a game where two players must see the same scramble, or a dataset where the scrambled form has to be regenerated later. Here the seed is part of the input and the algorithm is fully deterministic.
The seed string is hashed with FNV-1a, that hash drives a xorshift32 pseudo-random generator, and the generator drives a Fisher-Yates shuffle over the interior letters only. Change the seed and you get a different shuffle of the same word; change the word and the same seed maps to a new result.
What you can do with it
Generate reproducible puzzle content
Build word-scramble puzzles whose answers can be regenerated exactly, since the same word and seed always produce the same scramble.
Reading-perception classroom demos
Show students how interior-letter scrambling leaves words readable while first and last letters stay in place.
FAQ
Is the result random?
No. It is fully deterministic: the same word and seed always produce the same scrambled word. A different seed gives a different shuffle.
Why does it reject short words?
Words with fewer than four letters have at most one interior letter, so there is nothing to shuffle.
Do the first and last letters ever move?
Never. Only the letters strictly between the first and the last are shuffled.
Is anything stored?
No. The word is processed in memory and discarded; only the scrambled result is returned.
Can a scrambled word come out unchanged?
Yes. The result tells you whether the scramble actually changed the word. With short words the only possible shuffle can leave the inside letters in their original order, so the scrambled form matches what you typed.
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/text/scramble-word \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"word":"generation","seed":"kit-2026"}'const res = await fetch("https://api.kit.forhosting.com/text/scramble-word", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"word": "generation",
"seed": "kit-2026"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/scramble-word",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"word": "generation",
"seed": "kit-2026"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/scramble-word", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"word":"generation","seed":"kit-2026"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"word":"generation","seed":"kit-2026"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/scramble-word", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"word": "generation",
"seed": "kit-2026"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.scramble_word",
"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.
Limits
max_tokens | 20000 |
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 scramble word letters API takes a word and a seed and shuffles the interior letters of the word while keeping the first and last letters fixed, producing the classic effect where a scrambled word is still readable.
Why scrambling the interior keeps words readable
There is a well-known observation in popular linguistics: when the first and last letters of a word stay in place, readers can often still understand the word even when the letters in the middle are jumbled, because word recognition leans heavily on the overall shape of the word and its boundary letters. You send a word like 'generation' and a seed, and you receive back the same word with only the letters between the first and the last one shuffled. This endpoint automates exactly that transformation. The endpoint does not try to preserve readability guarantees — it simply performs the shuffle — but the underlying phenomenon is the reason the output usually remains legible to a human reader.
Input rules, errors and where it fits
The output reports the original word, the seed used, the scrambled result, the letter count, and whether the scramble actually changed the word — which can be false for short words where the only possible shuffle leaves the interior untouched. Typical integrations are puzzle and game backends, educational tools, demo-data generators and snapshot tests. The endpoint accepts two fields: 'word' (also accepted as 'text' or 'input') and 'seed' (also accepted as 'salt'). The word must contain at least four letters; with three letters or fewer there is at most one interior letter, so there is nothing meaningful to shuffle, and the endpoint answers with an invalid_input error that names the problem instead of silently returning the word unchanged. It runs on our global edge, stores nothing, and the identical code runs free in your browser on this page: you pay $0.002 per request only when you automate it through the API.
Integration use cases
Seed-stable test fixtures
Create scrambled variants of fixture text that snapshot tests can assert on, without flaky randomness between runs.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.