HTML Entities Reference: Every Escape Code You Need

Originally published on DevToolsHub — free, privacy-first online tools for developers.

HTML entities (also called character entities or escape codes) let you display
reserved characters, special symbols, and invisible characters in HTML documents.
Whether you need to show a literal < without
triggering a tag, display a copyright symbol, or include an arrow in your UI,
this reference has the code.

      Each table below lists the entity name, numeric code (decimal and hex), and the
      rendered character. Bookmark this page for quick lookup during frontend development.

💡 How to Use Use entity names like & or numeric
codes like & or
& directly in your HTML. Most modern
editors suggest entity names as you type.

Common Symbols

      These are the most frequently used HTML entities. Every developer should know
      `&amp;`, `<`,
      `>`, and ` `
      by heart.

Currency Symbols

      Display currency signs from around the world. Note that some symbols (like the
      Bitcoin sign) may not render in older browsers without a numeric code.

Arrows

      Arrow symbols for navigation, direction indicators, and UI elements. Both simple
      and double-lined variants are available.

Mathematical Operators & Symbols

      Common math symbols for equations, comparisons, fractions, and logic. Use numeric
      codes for symbols without named entities.

Punctuation & Special Characters

      Dashes, quotes, spaces, and other typographic characters for polished text.

Greek Letters (Common)

      Frequently used Greek letters in math, science, and engineering contexts.

**** 🎯 Quick Reference: Most Common Entities

&
&

          <

          `<`


          >

          `>`


          "

          `&quot;`




          ` `


          ©

          `&copy;`


          ®

          `&reg;`


          €

          `&euro;`

Common Mistakes & How to Avoid Them

      Entities look simple, but a few recurring mistakes cause broken pages, escaped-looking
      text, and subtle layout bugs. Here are the five most common ones.

1. Forgetting to escape the ampersand itself

      The `&` entity is special: because
      `&` starts every entity, a literal ampersand in your
      text (like `AT&T` or
      `R&D`) must be written as
      `&`. Otherwise the browser may try to parse
      `&T` or `&D` as an
      entity and render unexpected characters.

<!-- BUG: ambiguous, may render wrong -->
Acme & Sons

<!-- FIX: escape the ampersand -->
Acme & Sons

2. Dropping the trailing semicolon

      Writing `&copy` without the semicolon works in HTML5 in
      some contexts but is invalid in XHTML and risky inside attribute values. Always include the
      semicolon: `©`. The same applies to numeric
      references — `©` is correct,
      `&#169` is not.

3. Double-escaping entities

      If your page shows `<` as literal text instead of
      a `<` character, the content was escaped twice — once by
      your template engine or framework (React, Vue, Handlebars escape by default), then again by
      you. Pick one layer: let the framework escape user input, and never feed already-escaped
      strings into `dangerouslySetInnerHTML` or
      `innerHTML`.

// BUG: React already escapes, so this renders "<" as text

// FIX: write the raw character — React escapes it safely

// BUG: double-escaping user input for innerHTML
el.innerHTML = escapeHtml(userInput).replace(/&/g, '&');

4. Using for layout spacing

      Stacking ` ` entities to indent or align text works
      visually but breaks on narrow screens and with different font metrics. A non-breaking space
      also stops text from wrapping, which can push layout unexpectedly. Use CSS
      `margin`, `padding`, or
      `gap` for spacing instead — reserve
      ` ` for keeping two words on the same line (for
      example, "10 kg" or "Chapter 5").

5. Confusing decimal and hex numeric references

      `&` (decimal) and
      `&` (hex) both render
      `&`, but they are not interchangeable digits. Writing
      `8` renders the character `8`,
      not `&`. Check the prefix:
      `#x` means hexadecimal, plain
      `#` means decimal.

Frequently Asked Questions

Why use HTML entities instead of typing the character directly?

Three reasons: reserved characters like
<, >, and
& would be interpreted as markup;
encoding safety — an entity works even if the file encoding drops
the character (for example, a smart quote in a document declared as ASCII); and
reliability — invisible characters such as the non-breaking space
are hard to type and easy to mistake for a regular space.

What is the difference between and a regular space?

A non-breaking space ( , U+00A0) prevents
the browser from wrapping a line at that point, so "10 kg" stays together. It also
does not collapse: HTML collapses runs of regular spaces into one, but multiple
entities each keep their width, which is
why they are often misused for indentation. Use them for preventing breaks, not for
layout.

What is the difference between &, &, and &?

All three render the same & character.
& is the named entity — readable but only
available for characters that have a defined name. &
is the decimal numeric reference and & the
hex one; numeric references work for any Unicode code point, even ones without a
name. Use named entities for readability and numeric references for obscure symbols.

Do I need to escape quotes inside HTML attributes?

Only the quote that delimits the attribute needs escaping: in
the
inner double quotes must be ". Inside text
content, quotes are harmless and do not need escaping. Escaping them everywhere is
never wrong, but it makes source harder to read — escape only where required, and
prefer single quotes as attribute delimiters when the value contains double quotes.

Why does my page show < as literal text instead of <?

The text was escaped twice. If you write <
in your source, the browser parses & into
& and shows the literal text
<. This usually happens when a template
engine or framework that already escapes output receives pre-escaped input, or when
user input is escaped more than once. Escape at exactly one layer.

        **Related Tools:**
        [Base64 Encoder/Decoder](https://devtoolshub.cloud/tools/base64)

        [JSON Formatter](https://devtoolshub.cloud/tools/json-formatter)

        [Regex Tester](https://devtoolshub.cloud/tools/regex-tester)