DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG....



npm version Build and Test Downloads minified size gzip size dependents

DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG.

It's also very simple to use and get started with. DOMPurify was started in February 2014 and, meanwhile, has reached version 2.4.1.

DOMPurify is written in JavaScript and works in all modern browsers (Safari (10+), Opera (15+), Internet Explorer (10+), Edge, Firefox and Chrome - as well as almost anything else using Blink or WebKit). It doesn't break on MSIE6 or other legacy browsers. It either uses a fall-back or simply does nothing.

Our automated tests cover 19 different browsers right now, more to come. We also cover Node.js v14.x, v16.x, v17.x and v18.x, running DOMPurify on jsdom. Older Node versions are known to work as well, but hey... no guarantees.

DOMPurify is written by security people who have vast background in web attacks and XSS. Fear not. For more details please also read about our Security Goals & Threat Model. Please, read it. Like, really.

What does it do?

DOMPurify sanitizes HTML and prevents XSS attacks. You can feed DOMPurify with string full of dirty HTML and it will return a string (unless configured otherwise) with clean HTML. DOMPurify will strip out everything that contains dangerous HTML and thereby prevent XSS attacks and other nastiness. It's also damn bloody fast. We use the technologies the browser provides and turn them into an XSS filter. The faster your browser, the faster DOMPurify will be.

How do I use it?

It's easy. Just include DOMPurify on your website.

Using the unminified development version

  1. ``` html
  2. <script type="text/javascript" src="src/purify.js"></script>
  3. ```

Using the minified and tested production version (source-map available)

  1. ``` html
  2. <script type="text/javascript" src="dist/purify.min.js"></script>
  3. ```

Afterwards you can sanitize strings by executing the following code:

  1. ``` js
  2. let clean = DOMPurify.sanitize(dirty);
  3. ```

Or maybe this, if you love working with Angular or alike:

  1. ``` js
  2. import * as DOMPurify from 'dompurify';

  3. let clean = DOMPurify.sanitize('<b>hello there</b>');
  4. ```

The resulting HTML can be written into a DOM element using innerHTML or the DOM using document.write(). That is fully up to you.
Note that by default, we permit HTML, SVG and MathML. If you only need HTML, which might be a very common use-case, you can easily set that up as well:

  1. ``` js
  2. let clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { html: true } });
  3. ```

Where are the TypeScript type definitions?

They can be found here: @types/dompurify

Is there any foot-gun potential?

Well, please note, if you _first_ sanitize HTML and then modify it _afterwards_, you might easily void the effects of sanitization. If you feed the sanitized markup to another library _after_ sanitization, please be certain that the library doesn't mess around with the HTML on its own.

Okay, makes sense, let's move on

After sanitizing your markup, you can also have a look at the property DOMPurify.removed and find out, what elements and attributes were thrown out. Please do not use this property for making any security critical decisions. This is just a little helper for curious minds.

Running DOMPurify on the server

DOMPurify technically also works server-side with Node.js. Our support strives to follow the Node.js release cycle.

Running DOMPurify on the server requires a DOM to be present, which is probably no surprise. Usually, jsdom is the tool of choice and westrongly recommend to use the latest version of _jsdom_.

Why? Because older versions of _jsdom_ are known to be buggy in ways that result in XSS _even if_ DOMPurify does everything 100% correctly. There are known attack vectors in, e.g. _jsdom v19.0.0_ that are fixed in _jsdom v20.0.0_ - and we really recommend to keep _jsdom_ up to date because of that.

Other than that, you are fine to use DOMPurify on the server. Probably. This really depends on _jsdom_ or whatever DOM you utilize server-side. If you can live with that, this is how you get it to work:

  1. ``` sh
  2. npm install dompurify
  3. npm install jsdom
  4. ```

For _jsdom_ (please use an up-to-date version), this should do the trick:

  1. ``` js
  2. const createDOMPurify = require('dompurify');
  3. const { JSDOM } = require('jsdom');

  4. const window = new JSDOM('').window;
  5. const DOMPurify = createDOMPurify(window);
  6. const clean = DOMPurify.sanitize('<b>hello there</b>');
  7. ```

Or even this, if you prefer working with imports:

  1. ``` js
  2. import { JSDOM } from 'jsdom';
  3. import DOMPurify from 'dompurify';

  4. const window = new JSDOM('').window;
  5. const purify = DOMPurify(window);
  6. const clean = purify.sanitize('<b>hello there</b>');
  7. ```

If you have problems making it work in your specific setup, consider looking at the amazing isomorphic-dompurify project which solves lots of problems people might run into.

  1. ``` sh
  2. npm install isomorphic-dompurify
  3. ```

  1. ``` js
  2. import DOMPurify from 'isomorphic-dompurify';

  3. const clean = DOMPurify.sanitize('<s>hello</s>');
  4. ```

Is there a demo?

Of course there is a demo! Play with DOMPurify

What if I find a _security_ bug?

First of all, please immediately contact us via email so we can work on a fix. PGP key

Also, you probably qualify for a bug bounty! The fine folks over at Fastmail use DOMPurify for their services and added our library to their bug bounty scope. So, if you find a way to bypass or weaken DOMPurify, please also have a look at their website and the bug bounty info.

Some purification samples please?

How does purified markup look like? Well, the demo shows it for a big bunch of nasty elements. But let's also show some smaller examples!

  1. ``` js
  2. DOMPurify.sanitize(''); // becomes
  3. DOMPurify.sanitize(''); // becomes
  4. DOMPurify.sanitize('