React Render HTML

Unsure about how to render HTML in React without compromising security? This article will show you the way! Dive deep into safe methods for integrating external HTML content while exploring best practices for styling your React components. Learn how to leverage controlled components, sanitize untrusted data, and choose the right CSS-in-JS library to create a polished and secure application that looks as good as it performs.

Table of Contents

Rendering Raw HTML in React

While React primarily leverages JSX for building user interfaces, there might be situations where you need to render raw HTML within your components. This could be for integrating third-party content or displaying user-generated data. However, it’s crucial to understand the potential security risks involved and carefully choose the right approach.

Security Risks: A Reminder

Rendering raw HTML introduces the potential for security vulnerabilities like Cross-Site Scripting (XSS) attacks. If user-controlled data is directly inserted into HTML, malicious scripts could be injected, posing a threat to your application and users.

Choosing the Right Method: When Raw HTML Makes Sense

Despite the risks, there might be valid reasons to render raw HTML:

  • Content Management Systems (CMS)
    Display dynamic content fetched from a CMS using APIs. This HTML content can then be integrated seamlessly within your React application.
  • Third-Party Widgets
    Embed widgets or interactive elements from external providers. These widgets often come with their own HTML structure that needs to be rendered within your React component.
  • Social Media Feeds
    Integrate social media feeds directly into your React application by rendering the HTML response from the platform’s API.

Always prioritize security measures when rendering raw HTML. Here are some best practices:

  • Sanitize User Input
    Before rendering user-generated content, thoroughly sanitize it to remove potentially harmful scripts or tags. There are libraries available to assist with this process.
  • Consider Alternatives
    Explore alternative approaches that don’t involve raw HTML. For example, can you convert the content to a native format that React can handle (like plain text or structured data)?

Example: Rendering Third-Party Content (Use with Caution!)

Note: This example demonstrates rendering raw HTML, but it’s for illustrative purposes only. You must implement proper sanitization to mitigate security risks in a real application.

function SocialMediaFeed(props) {
    return (
        <div dangerouslySetInnerHTML={{ __html: props.feedHtml }} />


  • Line 1: Defines a functional component named SocialMediaFeed that accepts a prop named feedHtml.
  • Line 2-4: The return statement defines the JSX content for the component.
  • Line 3: Creates a div element.
    • dangerouslySetInnerHTML: This React property is used with caution to set the inner HTML content of the element.
      • It’s wrapped in an object with a __html property containing the raw HTML (props.feedHtml).

Remember: Rendering raw HTML can introduce security vulnerabilities. Use it judiciously, prioritize sanitization, and explore alternative approaches whenever possible.

Methods for Rendering HTML

Rendering HTML in React involves balancing convenience and security. For the quickest yet riskiest approach, the dangerouslySetInnerHTML attribute directly injects raw HTML. To prioritize security, explore safer alternatives like controlled components that carefully manage and sanitize user input. Consider custom React components to encapsulate complex rendering logic and third-party content, providing further security. For safer rendering of external HTML, parsing libraries like react-html-parser and DOMPurify sanitize content, reducing vulnerability risks. Remember, always prioritize security when incorporating external HTML into your React projects.

dangerouslySetInnerHTML for Rendering HTML

React’s dangerouslySetInnerHTML attribute allows you to insert raw HTML content directly into your components. While it offers flexibility, it comes with significant security risks.

How it Works

  • You provide a string containing HTML code.
  • React bypasses its usual sanitization and inserts the raw HTML into the DOM.

Example: (Use with Caution!)

import React from 'react';

function MyComponent({ content }) {
    return (
        <div dangerouslySetInnerHTML={{ __html: content }} />

export default MyComponent;


  • Line 5: The dangerouslySetInnerHTML attribute is used on a div element.
  • Line 5: The content prop is the __html property within an object. This injects the content string as HTML.

Security Concerns

  • XSS Attacks: If content contains malicious code, it can be executed in the user’s browser, leading to XSS vulnerabilities. Attackers could steal data, hijack sessions, or deface your application.

When to Avoid

  • Always prioritize security.
  • For user-provided content, explore controlled components for sanitization.
  • Consider custom React components with built-in security measures for third-party widgets or external content.

Parsing External HTML with Libraries

While dangerouslySetInnerHTML might seem like a shortcut, it opens security holes. Thankfully, there are safer ways to render external HTML in React using HTML parsing libraries. These libraries sanitize and transform untrusted HTML, removing potential threats before rendering it within your application.

  • react-html-parser
    Designed specifically for React, it parses and converts HTML into React elements.
  • DOMPurify
    A versatile library that sanitizes HTML, removing malicious code while preserving desired tags and attributes.

Sanitization with DOMPurify

Before rendering the HTML content, sanitize it using a library like DOMPurify. This library allows you to remove potentially dangerous elements and attributes from the HTML. After sanitization, you can then safely use dangerouslySetInnerHTML if necessary.

import React from 'react';
import DOMPurify from 'dompurify';

function MyComponent({ content }) {
    const cleanContent = DOMPurify.sanitize(content);
    return (
        <div dangerouslySetInnerHTML={{ __html: cleanContent }} />

export default MyComponent;


  • Lines 1-2: Import React and DOMPurify.
  • Line 5: The content is sanitized using DOMPurify’s sanitize method, removing potential threats.
  • Line 7: The sanitized cleanContent is then used with dangerouslySetInnerHTML, but with a much lower security risk due to prior sanitization.

Sanitization with react-html-parser or html-react-parser

These libraries parse HTML strings into React components while offering some level of protection against XSS. They provide more flexibility in handling HTML content compared to dangerouslySetInnerHTML.

import React from 'react';
import parse from 'html-react-parser';

const HtmlParserComponent = ({ content }) => {
    return <div>{parse(content)}</div>;

export default HtmlParserComponent;

Remember, for the examples that depend on external libraries (like DOMPurify and html-react-parser), you’ll need to install those libraries in your project using npm or yarn. For instance, you can run this command to install the necessary dependencies for the examples.

npm install dompurify html-react-parser

Manual Parsing and Rendering

For maximum control and safety, manually parse the HTML content and render it as React components. This approach is the most labor-intensive and is usually reserved for when you need fine-grained control over the rendering of HTML elements.

This might involve creating a utility that parses the HTML string, sanitizes it, and maps it to corresponding React components based on the tags and attributes. However, this method requires a significant amount of work and careful handling to ensure security and functionality.

Simplistic Example

import React from 'react';

const ManualParsingComponent = ({ content }) => {
    // A basic example of manual parsing; for demonstration purposes only
    const renderContent = () => {
        // Implement your parsing logic here
        return content;

    return <div>{renderContent()}</div>;

export default ManualParsingComponent;

Markdown as an Alternative

If the use case allows, consider using Markdown instead of raw HTML for content that needs formatting. Markdown is safer to parse and render compared to HTML. Libraries like remarkable or markdown-to-jsx can convert Markdown into safe React elements.


import React from 'react';
import Markdown from 'markdown-to-jsx';

const MarkdownComponent = ({ content }) => {
    return <Markdown>{content}</Markdown>;

export default MarkdownComponent;

For each of these components, you can import and use them in your main App component or any other component by passing the content prop, which should be the HTML you wish to render safely.

Security vs. Functionality in React HTML Rendering

When choosing a method to render HTML in React, you’ll navigate a trade-off between security and functionality. Here’s a breakdown of some common approaches:

1. dangerouslySetInnerHTML (High Risk, High Flexibility)

  • Functionality: Offers the most flexibility for directly injecting any HTML content.
  • Security: High Risk! Untrusted content can lead to XSS vulnerabilities.

Example (AVOID THIS!)

function MyComponent({ content }) {
    return (
        <div dangerouslySetInnerHTML={{ __html: content }} />


  • Line 3: Injects content directly using dangerouslySetInnerHTML. This is risky for untrusted content!

2. Controlled Components (Medium Security, Moderate Flexibility)

  • Functionality: Suitable for rendering user-provided content with proper sanitization.
  • Security: Moderately secure by controlling and sanitizing user input.


import React, { useState } from 'react';

// Assuming sanitizeUserInput is defined elsewhere or imported
function MyComponent() {
    const [userInput, setUserInput] = useState('');

    const handleChange = (event) => {
        setUserInput(sanitizeUserInput(; // Sanitize input before storing

    return (
            <input type="text" value={userInput} onChange={handleChange} />
            <div>{userInput}</div>  {/* Display sanitized content */}


  • Lines 5-9: Implement a controlled component to manage user input with sanitization (replace sanitizeUserInput with your sanitization function).
  • Line 14: Displays the sanitized userInput.

3. Custom React Components (High Security, High Flexibility)

  • Functionality: Highly flexible approach for handling complex rendering logic and third-party content.
  • Security: High security by allowing custom components to implement security measures during rendering.

Example (Component Structure, not full implementation)

function MySecureWrapper({ content }) {
    // Implement sanitization and secure rendering logic here
    const sanitizedContent = ...;
    return (
        <div dangerouslySetInnerHTML={{ __html: sanitizedContent }} />


  • This is a simplified example. The MySecureWrapper component would handle sanitization and secure rendering of the content prop.

Choosing Wisely

The ideal approach depends on your specific needs. For user-controlled content, prioritize controlled components. For complex scenarios, custom components offer more control and security. Remember, if using dangerouslySetInnerHTML, prioritize security by sanitizing content beforehand.