HTML Escape Characters: Complete List of HTML Entities

In today’s digital landscape, ensuring that web content is rendered correctly and securely is paramount. Web developers must navigate countless character sets, special symbols, and potential security vulnerabilities. One essential tool in that journey is the use of HTML escape characters—also known as HTML entities. These special codes allow you to display reserved or non-standard characters without breaking your HTML structure. In this comprehensive guide, we’ll explore what HTML entities are, why they’re important, a complete list of common entities, usage best practices, and how NuxLay Digital Agency can help you implement and optimise your website’s HTML for maximum performance, security, and user experience.

What Are HTML Escape Characters?

HTML escape characters, or HTML entities, are special sequences of characters that represent characters which either:

1. Are reserved in HTML (and would otherwise be interpreted as part of the markup),
2. Do not exist on a standard keyboard, or
3. May not render consistently across different browsers or character encodings.

An HTML entity always begins with an ampersand (&) and ends with a semicolon (;). For example:

• < represents the less-than sign (<)
• > represents the greater-than sign (>)
• & represents the ampersand (&)

These entities ensure that your intended characters appear exactly as intended, rather than being misinterpreted as HTML tags or broken code.

Why Use HTML Entities?

There are several compelling reasons to use escape characters in HTML:

1. Prevent Invalid Markup:
   Reserved characters such as <, >, and & have special meanings in HTML. Using them directly in text can break the document structure. For example, writing <script> without escaping could be interpreted as an actual tag.
2. Display Special Symbols:
   Not all symbols are available on a user’s keyboard. Entities allow you to show symbols like “™” (™), “©” (©), or mathematical signs like “≤” (≤).
3. Maintain Character Encoding Consistency:
   When working with multiple languages or accented characters, entities ensure consistent rendering across browsers that might interpret character sets differently.
4. Mitigate Security Risks (XSS Prevention):
   Properly escaping user input reduces the risk of cross-site scripting (XSS). If a user submits data containing < and >—which could potentially be HTML tags—escaping them (< and >) ensures the browser treats them as text rather than markup.
5. Improve SEO & Accessibility:
   Search engines and assistive technologies can misinterpret certain symbols if not properly encoded. Using the correct entity helps ensure that screen readers pronounce them correctly and that crawlers index content reliably.

Types of HTML Entities

HTML entities fall into two main categories:

1. Named Entities (Entity Names):
   These use a mnemonic name to represent a character. Example:   for a non-breaking space or é for “é.”
2. Numeric Entities:
   • Decimal (Base 10): Written as &#DDDD; where DDDD is the decimal code point. For example, © represents “©.”
   • Hexadecimal (Base 16): Written as &#xHHHH; where HHHH is the hexadecimal code point. For example, © also represents “©.”

Browsers interpret both named and numeric entities identically. However, named entities are more readable to humans, whereas numeric entities can cover a broader set of Unicode characters, especially those without standardized names.

Reserved Characters

Some characters are reserved in HTML because they define tags or control structures. The most common reserved characters are:

• & – Ampersand
• < – Less-than
• > – Greater-than
• " – Double quotation mark (used for attribute delimiters)
• ' – Apostrophe or single quotation mark (also used for attribute delimiters)

Trying to include these characters directly in HTML can lead to broken markup. Escape them using:

• & for &
• < for <
• > for >
• " for "
• ' (or ') for '

Named vs. Numeric Entities

• Named Entities:
  • Pros: Readability. You can tell at a glance that © is a copyright symbol.
  • Cons: There are only around ~250 to ~300 standardized named entities in HTML5.
• Numeric Entities:
  • Pros: Able to represent any Unicode character (up to U+10FFFF). If a named entity doesn’t exist for a character, you can always use its numeric code.
  • Cons: Harder to read; you must know the code point.

Example:

htmlCopyEdit<p>© 2025 Acme Corp. All rights reserved. &nbsp;Enjoy your visit!</p>
<p>&#169; 2025 Acme Corp. All rights reserved. &#160;Enjoy your visit!</p>

Both lines render identically. The first line uses named entities; the second uses numeric (decimal) entities.

Complete List of Common HTML Entities

Below is a categorized list of widely used entities. Rather than listing every single entity (which could span hundreds of entries), we provide the most essential and commonly used ones in each category. For a fully exhaustive list, refer to the W3C’s official HTML5 entity reference.

Basic Reserved Symbols

Character	Name	Entity Code
&	Ampersand	&
<	Less-Than	&lt;
>	Greater-Than	&gt;
"	Quotations (“)	&quot;
'	Apostrophe (’)	&apos; / &#39;

Tip: Use ' mainly in XML. For HTML, ' is safer cross-browser.

Whitespace Entities

Entity Name	Character Represented	Decimal Code
 	Non-breaking space	 
 	En space	 
 	Em space	 
 	Thin space	 
‌	Zero-width non-joiner	‌
‍	Zero-width joiner	‍

• Non-breaking Space ( ): Prevents an automatic line break at its position.
• En/Em Spaces: Wider spaces used for typographic alignment.

Latin-1 (ISO-8859-1) Entities

These are part of the ISO-8859-1 (Latin-1) character set. They include accented letters often used in Western European languages.

Name	Character	Decimal	Hexadecimal
¡	¡	¡	¡
¢	¢	¢	¢
£	£	£	£
¤	¤	¤	¤
¥	¥	¥	¥
¦	¦	¦	¦
§	§	§	§
¨	¨	¨	¨
©	©	©	©
ª	ª	ª	ª
«	«	«	«
¬	¬	¬	¬
­	(soft hyphen)	­	­
®	®	®	®
¯	¯	¯	¯
°	°	°	°
±	±	±	±
²	²	²	²
³	³	³	³
´	´	´	´
µ	µ	µ	µ
¶	¶	¶	¶
·	·	·	·
¸	¸	¸	¸
¹	¹	¹	¹
º	º	º	º
»	»	»	»
¼	¼	¼	¼
½	½	½	½
¾	¾	¾	¾
¿	¿	¿	¿

Example Usage:

htmlCopyEdit<p>Price: &pound;19.99</p>
<p>Temperature drop: 10&deg;C</p>

Mathematical Symbols

Web pages often require symbols for mathematical notation. Some commonly used math entities include:

Name	Symbol	Decimal	Hexadecimal
+	+	+	+
−	−	−	−
×	×	×	×
÷	÷	÷	÷
√	√	√	√
∞	∞	∞	∞
≤	≤	≤	≤
≥	≥	≥	≥
≠	≠	≠	≠
≈	≈	≈	≈
⊥	⟂	⊥	⊥
∑	∑	Σ	Σ
∏	∏	∏	∏

Example Usage:

htmlCopyEdit<p>For all x &infin; ℝ, x² ≥ 0.</p>
<p>The sum &sum; of the sequence is &sum;=1ⁿ n = n(n+1)/2.</p>

Currency Symbols

Global websites often display pricing in different currencies. HTML entities allow you to show currency symbols reliably:

Name	Symbol	Decimal	Hexadecimal
$	$	$	$
€	€	€	€
£	£	£	£
¥	¥	¥	¥
¢	¢	¢	¢
&poker;	₽	₽	₽
&rupee;	₹	₹	₹
&lira;	₺	₺	₺
&shekel;	₪	₪	₪

Example Usage:

htmlCopyEdit<p>Special Offer: &euro;49.99</p>
<p>Salary: &#8377;60,000 per annum</p>

Greek Letters

Greek letters are used in scientific, mathematical, and technical contexts. Common entities include:

Name	Symbol	Decimal	Hexadecimal
α	α	α	α
β	β	β	β
γ	γ	γ	γ
δ	δ	δ	δ
ε	ε	ε	ε
θ	θ	θ	θ
λ	λ	λ	λ
μ	μ	μ	μ
π	π	π	π
σ	σ	σ	σ
ω	ω	ω	ω

Example Usage:

htmlCopyEdit<p>The area of a circle: A = &pi;r<sup>2</sup></p>
<p>Coefficient of friction: &mu; = 0.45</p>

Miscellaneous Symbols

There are countless additional symbols—arrows, dingbats, geometric shapes, etc. Here is a sampling of widely used ones:

Name	Symbol	Decimal	Hexadecimal
•	•	•	•
…	…	…	…
′	′	′	′
″	″	″	″
‾	‾	‾	‾
⁄	⁄	⁄	⁄
™	™	™	™
®	®	®	®
§	§	§	§
¶	¶	¶	¶
†	†	†	†
‡	‡	‡	‡
‰	‰	‰	‰
‹	‹	‹	‹
›	›	›	›

Example Usage:

htmlCopyEdit<p>New Feature &bull; Improved Performance &bull;© 2025</p>
<p>Trademark: NuxLay&trade; Solutions</p>

Accented Letters (Extended Latin)

Web content in many languages requires accented characters. Here are some examples beyond the basic Latin-1 set:

Entity	Character	Decimal	Hexadecimal
À	À	À	À
Á	Á	Á	Á
Â	Â	Â	Â
Ã	Ã	Ã	Ã
Ä	Ä	Ä	Ä
Å	Å	Å	Å
Ç	Ç	Ç	Ç
È	È	È	È
É	É	É	É
Ê	Ê	Ê	Ê
Ë	Ë	Ë	Ë
Ì	Ì	Ì	Ì
Í	Í	Í	Í
Î	Î	Î	Î
Ï	Ï	Ï	Ï
Ñ	Ñ	Ñ	Ñ
Ò	Ò	Ò	Ò
Ó	Ó	Ó	Ó
Ô	Ô	Ô	Ô
Õ	Õ	Õ	Õ
Ö	Ö	Ö	Ö
Ø	Ø	Ø	Ø
Ù	Ù	Ù	Ù
Ú	Ú	Ú	Ú
Û	Û	Û	Û
Ü	Ü	Ü	Ü
Ý	Ý	Ý	Ý
à	à	à	à
á	á	á	á
â	â	â	â
ã	ã	ã	ã
ä	ä	ä	ä
å	å	å	å
ç	ç	ç	ç
è	è	è	è
é	é	é	é
ê	ê	ê	ê
ë	ë	ë	ë
ì	ì	ì	ì
í	í	í	í
î	î	î	î
ï	ï	ï	ï
ñ	ñ	ñ	ñ
ò	ò	ò	ò
ó	ó	ó	ó
ô	ô	ô	ô
õ	õ	õ	õ
ö	ö	ö	ö
ø	ø	ø	ø
ù	ù	ù	ù
ú	ú	ú	ú
û	û	û	û
ü	ü	ü	ü
ý	ý	ý	ý
ÿ	ÿ	ÿ	ÿ

Example Usage:

htmlCopyEdit<p>Café – Satisfy your cravings at our new &ldquo;Le Petit Bistro&rdquo; in downtown.</p>
<p>Français: &Eacute;t&eacute; (summer), &Egrave;cole (school), &Ntilde;and&uacute;</p>

Using Numeric (Decimal & Hex) Entities

While named entities cover many characters, thousands of additional Unicode code points lack named equivalents. Here’s how numeric entities work:

• Decimal Entity Format: &#DDDD;
• Hexadecimal Entity Format: &#xHHHH;

For example, the Unicode character U+2665 (the ♥ symbol) can be represented as:

• Decimal: ♥
• Hex: ♥

htmlCopyEdit<p>I &hearts; NuxLay Digital Agency!</p>
<p>I &#9829; NuxLay Digital Agency!</p>
<p>I &#x2665; NuxLay Digital Agency!</p>

All three lines render as “I ♥ NuxLay Digital Agency!”.

When to Use Numeric Entities

1. Unsupported Named Entities: If a character does not have a standardised name, you can still use its numeric code.
2. Ensure Compatibility: Some older browsers or specific environments might not recognise a named entity. Using the numeric version guarantees correct rendering.
3. Internationalisation: When your site needs to support Alphanumeric scripts beyond Latin-1 (e.g., Chinese, Arabic, etc.), numeric entities may be necessary.

Best Practices When Working with Entities

Ensuring your web pages use entities correctly can save time, improve user experience, and enhance security. Consider the following guidelines:

1. Validate Your HTML:
   Use validators (such as W3C’s Markup Validation Service) to catch unescaped reserved characters or malformed entities.
2. Use Named Entities for Core Characters:
   For common symbols—like <, >, &, ", and ©—stick to named entities. They improve readability for anyone editing your code.
3. Prefer UTF-8 Document Encoding:
   Modern best practice is to save your HTML files as UTF-8 and declare: htmlCopyEdit<meta charset="UTF-8"> This allows you to include most characters directly without using entities. However, reserved characters must still be escaped.
4. Escape User-Generated Content:
   When you display user input—comments, form data, etc.—always escape special characters to prevent XSS. Most templating engines (Laravel Blade, React JSX, etc.) handle this automatically, but double-check for manual concatenation.
5. Minimize Over-Escaping:
   Avoid turning every character into an entity. Only escape those that need it. Over-escaping (e.g., converting plain letters into A for “A”) makes your source code harder to read and maintain.
6. Document Your Entities:
   If your team often works with specific languages, symbols, or icons, maintain a shared reference document listing frequently used entities and their purpose.
7. Use Tools or Libraries:
   Many frameworks and libraries provide built-in functions to escape strings. In PHP, use htmlspecialchars() or htmlentities(). In JavaScript, libraries like DOMPurify help sanitize potentially unsafe input.

Common Pitfalls and How to Avoid Them

Even experienced developers can slip up when working with entities. Below are some typical mistakes and how to address them:

1. Forgetting the Semicolon:
   Writing &amp instead of & will not render correctly. Always end with a semicolon.
2. Double Escaping:
   If you escape already-escaped text (e.g., rendering < instead of <), users will see the literal code. Ensure you escape at the correct layer—usually when outputting to HTML, not before.
3. Incorrect Character Encoding Mismatch:
   If your HTML is declared as ISO-8859-1 but saved as UTF-8, some characters may misrender. Always ensure your file’s encoding matches the declared encoding.
4. Assuming All Characters Need Entities:
   Modern browsers support Unicode. If your file is UTF-8, you can embed most letters (é, ñ, ü) directly without entities. Reserve entities for special or reserved symbols.
5. Overreliance on Entities for Styling:
   Entities like   or multiple   might be tempting to achieve spacing, but CSS (margin, padding) is a more robust solution. Use entities sparingly for semantic meaning, not layout hacks.
6. Ignoring Accessibility:
   Some screen readers may interpret certain entities differently. For example, – vs. a literal hyphen “-”. Use entities that convey the correct semantic meaning (an en dash vs. a hyphen).
7. Missing Entities in Dynamic Content:
   When generating HTML dynamically (e.g., from a database), ensure you escape before inserting into the DOM. A missing escape can open doors for malicious scripts.

Tools & Resources for HTML Entities

Staying aware of the vast range of available entities can be daunting. Below are some tools to streamline the process:

1. W3C HTML Entity Reference (Official):
   • Comprehensive list of named and numeric entities.
   • W3C HTML5 Entities
2. Character Map Applications:
   • On Windows, use “Character Map” to copy and paste Unicode characters.
   • On macOS, use “Emoji & Symbols” (⌘ + Control + Space).
3. Online Converters:
   • Many online tools allow you to paste a string and automatically convert reserved characters into entities. Examples include “HTML Encoder” or “Text to HTML Entities” services.
4. Text Editors & IDE Plugins:
   • Visual Studio Code and Sublime Text have plugins that highlight and auto-convert characters to entities.
5. Browser Developer Tools:
   • Inspect existing pages to see how entities render. For instance, type <p>&copy; 2025</p> in DevTools to see the output.
6. Libraries for Programmatic Escaping:
   • PHP: htmlspecialchars(), htmlentities()
   • JavaScript: DOMPurify for sanitizing; or manually use textContent to prevent injection.
   • Python (Django, Flask): Use built-in templating escapes ({{ variable }} in Jinja2 auto-escapes).

Accessibility Considerations

Properly handling special characters and entities is vital for accessibility:

1. Screen Readers & ARIA:
   Some entities may sound different when read aloud. For instance, a non-breaking space ( ) may be read as a “space” or “blank.” For clarity, avoid excessive invisible characters in critical content.
2. Semantic Meaning:
   Using the correct entity conveys meaning. An en dash (–) is semantically different from a hyphen (-). Screen readers may interpret them differently, helping users understand context.
3. Avoid Decorative Entities in Text:
   If you use symbols purely for decoration (e.g., stars, arrows), consider using CSS or decorative <span> with aria-hidden="true" to prevent screen readers from announcing them.
4. Test with Assistive Technologies:
   Periodically run your site through a screen reader (NVDA, VoiceOver) to ensure entities are pronounced as intended and that there are no confusing artifacts.
5. Language Attributes:
   If you embed non-English text (e.g., accented letters or foreign scripts), wrap the text in an element with the appropriate lang attribute (e.g., <span lang="fr">Français</span>) so screen readers adjust pronunciation.

How NuxLay Digital Agency Can Help

At NuxLay Digital Agency, we understand that technical details such as HTML escape characters, character encoding, and entity management can be overwhelming—especially when your core focus is on delivering your products or services. Below are ways in which our team can support your organization:

1. Website Audit & Code Review:
   • Perform a comprehensive audit of your existing HTML/CSS/JavaScript codebase.
   • Identify any unescaped or improperly escaped characters that may cause malfunctions or security vulnerabilities.
   • Provide a detailed report and actionable recommendations to ensure your code adheres to best practices.
2. Secure Development & XSS Prevention:
   • Implement proper input validation and output escaping techniques in server-side languages (PHP, Node.js, etc.) and client-side frameworks (React, Vue, Angular).
   • Configure security headers (Content Security Policy, X-Content-Type-Options) to mitigate potential injection attacks.
   • Provide ongoing security audits to adapt to emerging threats and ensure your web application remains robust.
3. Internationalization (i18n) & Character Encoding Strategy:
   • Advise on best practices for supporting multiple languages and character sets in your website.
   • Configure your server and database to consistently use UTF-8 encoding, preventing character corruption or “mojibake.”
   • Guide you in selecting appropriate fonts and fallback strategies to display special characters across all devices and browsers.
4. Custom HTML Entity Utilization:
   • If you require specialized or brand-specific symbols (icons, logos, decorative glyphs), our design and development teams can create custom SVG icons.
   • Embed them efficiently with <svg> or CSS <span class="icon">, minimizing reliance on character entities that might not render consistently.
5. CMS & Template Integration:
   • Many clients use WordPress, Laravel, or other CMS platforms. We can configure your templates to ensure that dynamic data—such as blog posts, user comments, or product descriptions—is properly escaped before rendering in HTML.
   • Build custom shortcodes, filters, or Blade components that automatically encode reserved characters while preserving look and feel.
6. SEO & Semantic Markup Optimization:
   • Entities like  , –, and correct punctuation enhance readability and SEO. Our team can audit your markup to ensure that entities are used where they add semantic value.
   • Implement structured data (JSON-LD, Microdata) so search engines understand your content context, boosting rich snippet eligibility.
   • Guarantee that special characters in meta titles, descriptions, and URLs are escaped properly to prevent unintended truncation or misinterpretation by search engines.
7. Performance & Minification:
   • During CSS/JS minification, sometimes entities can be inadvertently altered. NuxLay will configure your build pipeline (Webpack, Gulp, etc.) to preserve critical entities.
   • Implement HTTP/2 push, Brotli compression, and proper MIME type settings to expedite entity-heavy pages (e.g., multilingual support).
8. Training & Documentation:
   • Conduct workshops or training sessions for your developers, teaching them how to use HTML entities correctly, prevent XSS, and manage character encoding.
   • Provide a detailed style guide and living documentation outlining your organization’s standard practices when dealing with special characters, ensuring consistency across your team.
9. Continuous Monitoring & Maintenance:
   • Offer ongoing support packages to monitor your site’s performance, security, and accessibility—focusing on encoding/escaping-related issues that might emerge due to software updates or third-party plugin changes.
   • Periodically run automated tests (using tools like Pa11y for accessibility, Lighthouse for performance) to catch entity-related problems before they affect real users.

Conclusion

HTML escape characters play a subtle yet vital role in web development. They safeguard your HTML from broken markup, allow you to present special symbols consistently, and protect against security vulnerabilities. Understanding named and numeric entities, when to apply them, and how to avoid common pitfalls ensures your website remains functional, secure, and accessible across all devices and browsers.

However, the technical intricacies of character encoding, entity management, and secure web development can be daunting. That’s where NuxLay Digital Agency steps in. With our deep expertise in frontend and backend development, security best practices, and SEO optimization, we help you harness HTML entities correctly, streamline your internationalization strategy, and keep your web presence robust and scalable. Whether you need a one-time audit or an ongoing partnership, NuxLay empowers your team to build, maintain, and enhance your digital assets with confidence.

Ready to take your website’s code to the next level? Contact NuxLay Digital Agency today for a free consultation. Let us handle the details—so you can focus on growing your business.

By applying the principles in this guide and partnering with NuxLay, you’ll ensure that every character, symbol, and piece of content on your website is displayed as intended—securely, efficiently, and accessibly.