Generate random words
Ask for five English words with seed 42 and you always get breeze, pearl, dance, year and unity: real words, never repeated, drawn from lists in six languages. Change the seed for a new set. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Quantity
- 5
- Language
- En
- Seed
- 42
- Available
- 100
- Words
- breeze, pearl, dance, year, unity
- Text
- breeze pearl dance year unity
Random dictionary words are a staple of writing warm-ups, captcha-style challenge strings, classroom vocabulary drills, and lightweight placeholder content when you want real-looking terms instead of pure gibberish. This generate-random-words capability accepts how many words you need, which language list to draw from, and an optional integer seed so the same request always returns the same ordered set.
Real words instead of gibberish
Random dictionary words are a staple of writing warm-ups, challenge strings, classroom vocabulary drills and placeholder content when you want real-looking terms rather than pure gibberish. You choose how many words you need and which of the six built-in lists to draw from: English, Spanish, French, German, Italian or Portuguese. Each word appears at most once per list, because the words are drawn without replacement, and you get them both as a list and as one line separated by single spaces, ready to paste into a form or an email.
The same seed, the same words
The draw does not rely on the computer's random number generator. It starts from a whole-number seed, one by default, and shuffles a copy of the dictionary in a fully predictable way, so the same seed, language and count always return the same words in the same order. Five English words with seed 42 give breeze, pearl, dance, year and unity, every time. To get a different set, keep the language and the count and change only the seed. A teacher can give every student the same list for a lesson and rotate seeds from week to week, and a game designer can pin a seed for hangman, bingo or word-ladder playtests.
What the random word generator returns and why it is seeded
A request asks for a positive integer count of distinct words drawn from one of six built-in language dictionaries: English (en), Spanish (es), French (fr), German (de), Italian (it), or Portuguese (pt). The sampler does not call the system random number generator. Instead it advances a deterministic linear congruential generator from an integer seed (default one when omitted) and uses those stream values to partial-shuffle a copy of the list, then takes the first count entries.
Because the stream is fully determined by seed, language, and count, two clients that post the same body receive identical words and the same joined text field. If you need a different bag of words for the same language and count, change the seed; leave language and count fixed and only the seed varies.
What you can do with it
Classroom vocabulary drills
Generate a fixed-size set of target words per lesson seed so every student sees the same list while you still rotate seeds between weeks.
Puzzle and game word pools
Draw hangman, bingo, or word-ladder vocabularies without replacement and pin a seed for reproducible playtests and recordings.
FAQ
How do I generate random dictionary words?
Send count (positive integer), language (en, es, fr, de, it, or pt), and optionally seed.
What happens if count is larger than the word list?
The message includes the requested count and the available size for that language. Failed validation is not billed.
Are the words truly random?
They are pseudo-random and fully deterministic: a seeded LCG drives a without-replacement shuffle. Same seed, language, and count always yield the same ordered list.
Which languages are supported?
Six built-in lists: English (en), Spanish (es), French (fr), German (de), Italian (it), and Portuguese (pt). Other codes are rejected by the enum contract.
Can a word appear twice in the same list?
No. Words are drawn without replacement, so each one appears at most once per list. Ask for five words and you get five different words from the chosen dictionary.
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/random-word-generate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"count":5,"language":"en"}'const res = await fetch("https://api.kit.forhosting.com/text/random-word-generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"count": 5,
"language": "en"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/random-word-generate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"count": 5,
"language": "en"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/random-word-generate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"count":5,"language":"en"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"count":5,"language":"en"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/random-word-generate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"count": 5,
"language": "en"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.random_word_generate",
"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
Selection is sample-without-replacement from a fixed in-memory dictionary: you never get duplicates in one response, and you get a clear invalid_input error if the count exceeds the list size for that language.
What the random word generator returns and why it is seeded
Words are always unique within a single response: the shuffle is without replacement, so asking for five English words never repeats apple twice in that payload. The response echoes count, language, and seed, reports available as the full list length for that language, returns words as a string array, and includes text as those words joined by single spaces for quick paste into forms or emails.
Input contract, limits, and error behaviour
Language must be one of the enum codes en, es, fr, de, it, or pt—free-form locale tags and unsupported codes are rejected so the web form can stay a simple select control. Seed, when present, must be a non-negative integer up to two billion one hundred forty-seven million four hundred eighty-three thousand six hundred forty-seven; when absent the engine uses seed one so examples stay stable. POST a JSON body with required fields count and language, plus optional seed. Count must be a finite integer from one through five hundred; non-integers, zero, negatives, and missing values fail with invalid_input naming the field. The hard product rule is that count may not exceed the available dictionary size for the chosen language: each list ships with a fixed number of everyday dictionary-style tokens, and requesting more than that size fails with a message that includes both the requested count and the available size. That failure is intentional product design rather than silent padding with repeats, because many callers use the output as unique tokens for labels, quiz options, or temporary usernames. Successful calls cost the published $0.002 base price on the API; invalid input is not billed.
Where seeded random words earn their keep in real workflows
Game and puzzle prototypes draw random word pools for hangman-style rounds, word ladders, or bingo cards, pinning a seed so a recorded playthrough always shows the same board. Localization QA teams pull the same count across en, es, fr, de, it, and pt to smoke-test layout width with realistic dictionary tokens instead of repeated filler. Pair it with your own uniqueness store if you need global de-duplication across many requests; within one call the contract already guarantees distinct words up to the list length. Language teachers and app authors build vocabulary drills that need a fresh but reproducible set of target words for each lesson id: storing a seed per lesson regenerates the same list for every student without shipping a static JSON file. Because the capability is tier A parse, it runs free in the browser for interactive demos and at $0.002 per successful API call for scripts, with no model tokens and no outbound network.
Integration use cases
Deterministic fixture and placeholder data
Fill forms, demo tables, and CI snapshots with real-looking multi-language dictionary words that never change for a given seed.
Technical questions
What does the random word generator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.