Lorem ipsum generator
Ask for exactly 12 words with seed 7 and you get the same placeholder line every time, starting with Lorem ipsum dolor sit amet. Request words, sentences or paragraphs, up to one thousand at once, and layouts stay stable between reviews. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Quantity
- 12 words
- Seed
- 7
- Words
- 12
The lorem ipsum generator produces classic Latin-style placeholder text in exactly the amount you ask for: a number of words, sentences or paragraphs, up to one thousand units per single call. Because it works from a deterministic seed, the same request always returns the same text, which makes it safe to use in tests, snapshots, design reviews and any pipeline where a layout must be filled with predictable dummy copy.
Placeholder text that fits the exact space you need to fill
Every designer and developer knows the drill: a layout is not finished until you see how real-looking copy flows through it, but the real copy does not exist yet. The lorem ipsum generator solves that gap with the classic pseudo-Latin text the industry has used for decades. There is no trimming a paragraph by hand until it fits a card, and no padding a sidebar with repeated fragments.
Words mode gives you an exact word count for headlines and microcopy tests; sentences mode produces grammatically shaped units with varied lengths for captions and list items; paragraphs mode returns full blocks separated by blank lines, ready to drop into an article mockup. The generator also respects the tradition of starting with the famous "Lorem ipsum dolor sit amet" opening, so the result is instantly recognizable as placeholder copy to anyone reviewing your work, and nobody mistakes it for unfinished real content.
Deterministic seeds: the same input always gives the same text
Randomness is the enemy of reproducible builds. If your visual regression suite screenshots a page filled with placeholder text, a different text on every run means a different screenshot on every run, and your tests become noise. This generator is fully deterministic: it derives a pseudo-random stream from an integer seed you control, with no clock, no network and no true randomness involved anywhere.
Send count, unit and seed, and the response is byte-for-byte identical today, tomorrow and on any machine. Different seeds give different texts, so you can vary the filler between components while keeping each one stable. The three units are salted separately, so asking for five words and five sentences with the same seed never produces overlapping output.
It is a small contract, but it is the one that makes the tool safe to automate.
How to call it and what you get back
The contract is deliberately small. You send a count, a unit chosen from words, sentences or paragraphs, and an optional seed; you receive the generated text, the echoed parameters and the total word count. Sentences run between six and fifteen words and paragraphs between three and six sentences, which mirrors the rhythm of real editorial copy closely enough for layout testing without pretending to be meaningful prose.
What you can do with it
Fill a design mockup with realistic copy
Generate exact amounts of placeholder text for cards, sidebars and article layouts so stakeholders review real proportions instead of empty boxes.
Stress-test a CMS or template engine
Push hundreds of paragraphs of deterministic dummy content through a rendering pipeline to check pagination, truncation and typography edge cases.
FAQ
Is the output the same every time?
Yes. The generator is fully deterministic: the same count, unit and seed always produce byte-identical text. Change the seed to get a different text.
Can I get the classic "Lorem ipsum dolor sit amet" opening?
Yes, the output starts with it by default.
How is this different from dev.lorem?
dev.lorem uses a language model to write placeholder text about your actual topic. This capability returns classic pseudo-Latin, deterministically, with no AI involved — ideal when you need reproducible filler, not topical copy.
How long are the generated sentences and paragraphs?
Sentences run between six and fifteen words, and paragraphs between three and six sentences, separated by blank lines. That rhythm is close enough to real editorial copy to judge how a layout will look.
How do I get different filler for each part of a page?
Give each component its own seed, since different seeds give different texts and each one stays stable. Words, sentences and paragraphs are also generated independently, so five words and five sentences with the same seed never overlap.
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/lorem-ipsum-generate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"count":5}'const res = await fetch("https://api.kit.forhosting.com/text/lorem-ipsum-generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"count": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/lorem-ipsum-generate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"count": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/lorem-ipsum-generate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"count":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"count":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/lorem-ipsum-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
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.lorem_ipsum_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_count | 1000 |
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
Placeholder text that fits the exact space you need to fill
What makes this endpoint different from copying a static block is precision: you ask for exactly twelve words, three sentences or two paragraphs and you receive exactly that amount, counted for you.
How to call it and what you get back
Anything outside that contract is rejected with a typed invalid_input error before any work happens: an unsupported unit such as "lines" fails fast and is never charged, a count below one or above one thousand is refused with the valid range in the message, and a non-integer seed is rejected as well. The capability is free to use in the browser on this page — the very same code runs there — and costs $0.002 per request when you call it through the API. No account is needed to try it, no file is stored after the call, and the output is plain text you can copy, download or pipe straight into your templates.
Integration use cases
Stable fixtures for visual regression tests
Because the same seed always yields the same text, screenshot tests and snapshot fixtures stay reproducible across runs and machines.
Technical questions
What does it cost?
$0.002 per request via the API. It is also free to run in your browser on this page, with the same deterministic output.
Which units can I generate?
Words, sentences and paragraphs, from 1 to 1000 units per call. Any other unit is rejected with an invalid_input error.
Is anything stored after the call?
No. The text is generated in memory, returned, and discarded. Nothing you send or receive is kept.