Why use dummytxt instead of other lorem ipsum generators?

Most lorem ipsum generators give you plain paragraphs. dummytxt generates configurable HTML output with headings, lists, images, tables, and inline formatting you can paste straight into your codebase, CMS, or design tool.

Does dummytxt require an account or registration?

No. dummytxt is fully client-side with no account, no rate limits, and no data sent to any server.

What HTML elements can dummytxt generate?

Paragraphs, headings (H1–H6), ordered and unordered lists, placeholder images in three sizes, blockquotes, tables, code blocks, dividers, and inline bold, italic, and link elements.

Can I copy the output as plain text instead of HTML?

Yes. dummytxt lets you copy the output as either raw HTML code or clean plain text with a single click.

How is dummytxt useful for CMS and WordPress development?

CMS editors produce content with headings, tables, images, and lists — not just plain paragraphs. dummytxt lets you configure exactly that element mix so you can test your WordPress theme, headless CMS renderer, or WYSIWYG editor against realistic content before launch.

Does dummytxt work with Contentful, Sanity, or other headless CMS platforms?

Yes. Copy the HTML output and use it as a fixture to test your rich-text renderer. Both Contentful's rich text and Sanity's Portable Text ultimately serialise to HTML — dummytxt gives you a comprehensive reference to validate your renderer against.

Guide

Why plain lorem ipsum fails your layouts — and how to fix it

Most lorem ipsum generators hand you walls of uniform paragraphs. The moment a real editor pastes in a heading, drops a table, or uploads an image with a caption, your layout breaks. This guide explains how dummytxt solves that problem and how to get the most out of it.

The problem with plain lorem ipsum

Lorem ipsum has been the default placeholder text since the 1960s, and for good reason — it fills space without drawing attention to itself. But plain paragraphs only test one thing: that your p tag renders correctly.

Real editorial content is messy. A WordPress post might open with an H2, include a two-column table halfway through, embed a pull quote, and end with a numbered list of takeaways. If your theme or component was only tested against plain paragraphs, that structure will break — often in production, not in development.

The same problem applies to headless CMS setups. Whether you're using Contentful, Sanity, Payload, or any other platform, your rich-text renderer needs to handle every element your editors can produce. Testing it with plain text is like testing a bridge with a bicycle when the design spec calls for trucks.

Elements commonly missed by plain lorem ipsum

→Heading hierarchy (H1 through H6 in sequence)
→Ordered and unordered lists inside paragraphs
→Inline bold, italic, and linked text mid-sentence
→Block-level images with captions
→Data tables with headers and body rows
→Blockquotes and pull quotes
→Inline code and code blocks
→Horizontal rules and section dividers

Getting started in three steps

Configure your content

Use the control panel on the left to set how many paragraphs you want, which heading levels to include, and which block-level elements to insert. Every toggle is live — the output updates instantly as you change settings.

Choose your output format

Switch between HTML and plain text modes. HTML mode gives you raw markup you can paste directly into a code editor, template file, or CMS rich-text field. Plain text mode strips all tags for environments that only accept text.

Copy and paste

Hit the Copy button. The output is on your clipboard. Paste it into your WordPress editor, your Contentful entry, your Storybook story, or your design tool. No sign-up, no rate limit, no server call.

Configuration reference

Every option in the control panel affects how the output is structured. Here's what each one does and when to use it.

Paragraph count

Controls how many body paragraphs appear in the output. For a quick component test, 2–3 is usually enough. For full-page layout testing, 8–12 gives you realistic scroll depth and enough content to stress pagination, sidebars, and sticky elements.

Headings (H1–H6)

Select which heading levels to inject. dummytxt inserts them at natural intervals between paragraphs — not uniformly, which matches how a real editor writes. Use H2 and H3 for typical article layouts. Add H4–H6 if your design system has deep content hierarchies.

Unordered lists

Inserts bulleted lists. These appear as standalone blocks between paragraphs. Essential for testing how your list styles interact with surrounding paragraph spacing. The item count is configurable — test with 3 items for typical use, 7–10 to stress-test wrapping and vertical rhythm.

Ordered lists

Same as unordered but numbered. Particularly important for step-by-step instructional layouts where counter resets and list-style-type rendering can vary across browsers.

Inline elements (bold, italic, links)

When enabled, short runs of text within paragraphs are randomly wrapped in <strong>, <em>, or <a> tags. This is the closest dummytxt gets to realistic body copy. Real editorial content uses inline formatting constantly — test without it and you may ship a layout where linked text has no visible differentiation from body text.

Placeholder images

Injects <figure> elements with <img> and <figcaption>. Three sizes are available: small (320px), medium (640px), and large (1024px). Use large images to test how your layout constrains oversized media — a common breakage point in CMS themes.

Blockquotes

Inserts <blockquote> elements styled for pull quotes or cited material. Critical for journalism and editorial layouts where blockquote styling often breaks down under real content.

Tables

Injects a <table> with header rows and body rows. Tables are among the hardest elements to style responsively — generate one and immediately resize your viewport to check overflow behaviour.

Code blocks

Inserts <pre><code> elements. If your site renders technical content, test this to verify your monospace font loads correctly and that overflow: auto is working on narrow screens.

Use cases

WordPress theme development

WordPress's block editor (Gutenberg) lets authors combine every element dummytxt can generate: heading blocks, list blocks, image blocks with captions, table blocks, quote blocks, and code blocks — all in a single post. If you're developing a theme or a custom block plugin, generate a full-featured output and paste it into the Classic Editor or a Paragraph block to confirm your content.php styles hold.

Save the generated HTML as a fixture in your theme's test data folder. Reuse it during every CSS change to catch regressions before they reach staging.

Headless CMS — Contentful, Sanity, Payload

When you build a rich-text renderer for a headless CMS, you're mapping every node type your editors can produce to a React (or other) component. Copy dummytxt's HTML output and use it as the expected input for unit tests on your renderer. This is far more reliable than handwriting fixture HTML, and covers edge cases like back-to-back list blocks, nested inline elements, and figures adjacent to tables.

Contentful's rich text field serialises content as a structured document tree. Sanity's Portable Text is similar. Both ultimately render to HTML — the dummytxt output is a good reference for the HTML your renderer should produce.

Design system and Storybook stories

Component stories that use hardcoded two-word labels or a single "Lorem ipsum dolor sit amet" paragraph miss most typographic edge cases. Use dummytxt to generate varied-length placeholder content for your Article, Card, Modal, and Drawer stories. Run with 1 paragraph for a compact card, 8 for a full article view. Vary inline elements to confirm your link and strong styles work in context.

WYSIWYG editor validation

If you're embedding TipTap, Quill, ProseMirror, or any other WYSIWYG editor in a product, you need to verify it handles all the content types your users will paste. Copy dummytxt's HTML output and paste it into the editor to test import fidelity — does it preserve heading levels? Does it parse table structure? Does it keep inline formatting? You'll find issues immediately rather than when a user files a bug.

Pro tip: save output as fixture files

Don't treat dummytxt as a one-time tool. Generate a comprehensive output once — with headings, lists, inline elements, images, and a table — and save it as a fixture.html file in your project's test or stubs directory.

Reference that fixture in your CSS regression tests, Storybook stories, and Playwright snapshots. Every time you change your typography or layout styles, the fixture content reveals breakages that isolated component tests miss. Version-controlled fixtures also make it easy to review what your content looked like before and after a style change.