Failed to execute 'toDataURL' on 'HTMLCanvasElement': Tainted canvases may not be exported
  • 29-May-2023
Lightrun Team
Author Lightrun Team
Failed to execute 'toDataURL' on 'HTMLCanvasElement': Tainted canvases may not be exported

Failed to execute ‘toDataURL’ on ‘HTMLCanvasElement’: Tainted canvases may not be exported.

Lightrun Team
Lightrun Team

Explanation of the problem

I am encountering a tainted canvas error despite having the allowTaint flag set to false. This issue is similar to problem #1409. The URL I am currently testing is: Unfortunately, I am unsure how to set up a jsFiddle to replicate the problem. However, I have conducted tests using a Chrome extension that utilizes the executeScript functionality.

Extension Code:

var captureScreenCode = 
  `html2canvas(document.body, {
    allowTaint: false,
    useCORS: false
    }).then(function(canvas) {
chrome.tabs.executeScript(1234, { file: 'html2canvas.js' }, () => {
  chrome.tabs.executeScript(1234, { code: captureScreenCode });

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for Failed to execute ‘toDataURL’ on ‘HTMLCanvasElement’: Tainted canvases may not be exported.

One possible solution to address the tainted canvas error is to modify the behavior of the Image constructor. By temporarily overriding the default behavior, we can set the crossOrigin property of the image object to ‘anonymous’, ensuring proper handling of cross-origin content. This approach involves creating a temporary reference to the original Image constructor and then redefining it. Within the redefined constructor, a new image object is created and configured with the appropriate crossOrigin value. This workaround has been reported to resolve the issue successfully.

Another approach that has proven effective for resolving the tainted canvas error is to switch to using the “dom to image” library instead of the html2canvas library. By utilizing the “dom to image” library, users have reported that they were able to overcome the issue they were facing. This library offers an alternative solution for capturing and rendering DOM elements into images. By adopting this library as a replacement for html2canvas, users have found that their specific problem with the tainted canvas error was resolved.

In summary, if you encounter a tainted canvas error despite setting the allowTaint flag to false, there are a couple of potential solutions to consider. The first option involves modifying the behavior of the Image constructor by temporarily overriding it and configuring the crossOrigin property of image objects. This workaround has been found to work in certain cases. Alternatively, switching to the “dom to image” library has proven effective for other users who faced similar issues. By utilizing one of these approaches, you can mitigate the tainted canvas error and continue capturing and rendering DOM elements successfully.


Other popular problems with html2canvas


Problem: Tainted Canvas Error despite Setting allowTaint Flag

One of the most common issues encountered when using the html2canvas library is the persistent occurrence of a tainted canvas error, even when the allowTaint flag is explicitly set to false. This error typically arises when attempting to capture and render images from cross-origin sources. Despite configuring the library to disallow tainting, the error persists, preventing the generation of canvas-based representations of the desired content.


To address this issue, a workaround involves modifying the behavior of the Image constructor by overriding its default implementation. By doing so, we can explicitly set the crossOrigin property of the image object to ‘anonymous’, enabling proper handling of cross-origin content and bypassing the tainted canvas error.

Problem: Incorrect Rendering of DOM Elements

Another prevalent problem when using html2canvas is the inaccurate rendering of certain DOM elements. This issue can manifest as elements being misplaced, incorrectly sized, or missing from the rendered image output. It often occurs when capturing complex layouts, dynamic content, or elements with complex CSS properties.


To mitigate the incorrect rendering of DOM elements, it is recommended to optimize the rendering process by allowing ample time for the DOM to fully load and stabilize before capturing. Additionally, setting explicit CSS properties, such as width and height, for the target elements can help ensure their correct dimensions in the rendered output.

Problem: Performance and Memory Consumption Issues

html2canvas can sometimes introduce performance and memory consumption issues, especially when capturing large or complex DOM structures. This can lead to slow rendering times, high CPU usage, or even crashes in extreme cases. The library’s default rendering algorithm may not efficiently handle complex layouts, excessive DOM nodes, or frequent updates, impacting the overall performance and user experience.


To improve performance and mitigate memory consumption issues, there are several strategies to consider. One approach is to limit the capture area to specific elements or sections of the page instead of rendering the entire DOM.

A brief introduction to html2canvas

html2canvas is a popular JavaScript library that enables capturing and rendering of HTML elements into a canvas object. It provides a powerful toolset for generating screenshots or converting complex HTML structures into image representations. The library works by traversing the DOM tree and rendering each element onto a canvas, preserving the visual layout, styles, and content. It supports a wide range of features, including capturing specific elements or regions, handling cross-origin content, and applying various configuration options for customization. By leveraging the canvas element and the underlying rendering capabilities of browsers, html2canvas facilitates the creation of visual representations of web content, making it a valuable tool for tasks such as screenshot generation, image manipulation, and PDF generation from HTML sources.

html2canvas offers extensive support for rendering various types of HTML content, including text, images, backgrounds, gradients, and CSS transformations. It handles complex layouts, such as nested elements and overlapping content, while accurately preserving the relative positioning and stacking order of the captured elements. The library employs a combination of techniques, such as HTML parsing, CSS computation, and canvas rendering, to faithfully reproduce the visual appearance of the captured content. Furthermore, html2canvas provides options for fine-tuning the rendering process, including setting explicit dimensions, configuring timeouts, and adjusting the quality of the output. It also offers event hooks for capturing intermediate rendering stages or performing post-processing operations on the generated canvas. With its comprehensive feature set and flexible configuration options, html2canvas serves as a reliable and versatile solution for capturing and transforming HTML content into visual representations, empowering developers to create rich and dynamic experiences.

Most popular use cases for html2canvas

  1. Screenshot Generation: html2canvas is commonly used to generate screenshots of HTML content within web applications. By capturing the visual representation of specific elements, sections, or entire web pages, developers can create screenshots for various purposes, such as documentation, user interface testing, bug reporting, or generating previews. The library’s ability to faithfully render HTML content, including complex layouts, styles, and images, makes it a valuable tool for accurately capturing and preserving the visual appearance of web-based interfaces.
  2. Image Manipulation: Another application of html2canvas lies in image manipulation. The library enables developers to convert HTML content into a canvas object, which can then be processed and transformed using various canvas APIs or third-party libraries. This opens up possibilities for applying custom filters, performing image editing operations, adding annotations or overlays, or creating composite images. By leveraging html2canvas, developers can harness the power of the canvas element and its associated image manipulation capabilities to create dynamic and visually rich user experiences.
  3. PDF Generation: html2canvas can be utilized to generate PDF documents from HTML content. By capturing the desired HTML elements and rendering them into canvas objects, developers can subsequently convert these canvases into PDF files. This capability is particularly useful for scenarios where web-based content needs to be transformed into printable or shareable documents, such as generating invoices, reports, or presentations. By combining the rendering capabilities of html2canvas with additional libraries or APIs for PDF generation, developers can seamlessly convert dynamic HTML content into professional-looking PDF documents.

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.