Intersection Observer API for lazy loading and scroll events

Anton Ioffe - November 6th 2023 - 8 minutes read

As web developers, we are always in search of strategies to optimize browser performance, enhance user experience, and manage resources efficiently. In the quest to meet these needs, JavaScript presents us with the powerful Intersection Observer API. In this article, we will unpack the intricacies of this API, how it stacks up against traditional event-driven methods, and how it plays an essential role in modern web development practices like lazy loading and scroll events. By debunking common myths, teaching best-practice coding, and offering real-world examples, we aim to provide a comprehensive guide that will elevate your understanding of the Intersection Observer API and, ultimately, impact the way you view JavaScript's role in web performance optimization.

Understanding the intersection observer

The Intersection Observer API is an integral part of modern web development. It offers an optimal way to asynchronously observe changes in the intersection of a target element with an ancestor element or the viewport of the top-level document. In other words, it avails an effective method to track the visibility and position of DOM elements in relation to a containing element or the overall viewport. This functionality proved instrumental in maintaining an efficient balance of resource utilization in relation to visibility, resulting in superior web performance and user experience.

At the heart of the Intersection Observer API are its omnipresent 'watchers’. They vigilantly observe elements as they move in and out of the viewport, responding in real-time to visibility changes. The Intersection Observer API functions as a tireless overseer, tracking the visibility state of elements with precision and efficiency.

The Intersection Observer API comes with key components that contribute to its power and effectiveness. The main components are a target—the element to be observed—and a root—the element that acts as the viewpoint for determining the target's visibility. The Intersection Observer API's strength comes from the flexibility and versatility of these key components. The root, for instance, defaults to the browser viewport but can be switched to any other element in the DOM to eliminate any constraints on observation.

Gaining a deep understanding of the Intersection Observer API is crucial for any web developer looking to stay in step with modern development practices. This understanding lays the groundwork for enhancing web performance by skillfully managing resources in line with viewport visibility. By mastering the Intersection Observer API, developers can better address common web development challenges, potentially resulting in increased efficiency, and a richer user experience.

Comparing the Intersection Observer API and traditional event methods

The Intersection Observer API and event-driven methods are both viable options for handling events related to DOM elements in JavaScript, but they offer different advantages and might be better suited to different tasks. The Intersection Observer API operates on an asynchronous basis, observing changes in the intersecting behavior of target elements with the viewport and triggering a reaction when the threshold is crossed. The benefits of this approach are manifold: It avoids unnecessary calculations on even the smallest scroll movement, it's not contingent on continuous manual calculations for a component's position, and it provides better performance for large scale projects.

Event-driven methods, on the other hand, function synchronously and require active listening for the occurrence of various events such as a scroll, and then responding to the event then and there. This traditional approach bears the brunt of continuous monitoring, which results in more heavy lifting for the browser, especially during tiny scroll movements. However, the event-driven methods find their advantage where fine-tuned, exact control is required or where there's a need to respond immediately to certain events.

Real-world code would illustrate the stark contrast between the two approaches. An image lazy-loading code using the Intersection Observer API would look something like this:

const observer = new IntersectionObserver((entries) => {
    entries.forEach((entry) => {
      if (entry.isIntersecting) {
        const img =;
      img.src = img.getAttribute('data-src');

document.querySelectorAll('img').forEach((img) => {

On the contrary, event listeners need continuous monitoring and manual calculations for the same task:

window.addEventListener('scroll', () => {
    document.querySelectorAll('img').forEach((img) => {
      const rect = img.getBoundingClientRect();
    if ( >= 0 && rect.bottom <= window.innerHeight) {
        img.src = img.getAttribute('data-src');

Both these approaches ensure that images not in the viewport are not loaded until necessary. Still, you can see the evident disparity in simplicity, code verbosity, and the heavier load event listeners place on the browser.

Given these key differences, deciding which method to use often comes down to compatibility and performance constraints. While Intersection Observer takes the edge on performance and simplicity, some legacy or heavily constrained environments might require sticking with traditional event listeners. Ultimately, understanding both these approaches can unlock more efficient, readable, and adaptable web development. Just as ought to be asked: Are you adhering to the age-old methods out of mere familiarity, or is it time to delve into the modern approaches that browsers themselves offer?

Deconstructing the Intersection Observer API mechanics

First and foremost, the Intersection Observer is constructed with two arguments. The first argument is a callback function that gets invoked when the target element intersects with the root. In the second argument, an options object is passed which includes parameters such as root, rootMargin, and threshold. Here is a simple example:

var options = {
    root: null, // defaults to the viewport
    rootMargin: '0px',
    threshold: 0.5
var observer = new IntersectionObserver(callback, options);

The observe() method is then employed to instruct the observer to watch a specific DOM element. Passing the target element (e.g., an image) into this method triggers the observer when conditions, as per the options configured, are met.

const img = document.getElementById('target-image');

Delving further, the root option in the configuration defines the area within which the visibility of the target is observed. Setting it to null implies observation within the entire viewport. The rootMargin extends this root's intersection area, allowing pre-emptive actions even before the target actually enters the viewport. Threshold, containing value(s) between 0 and 1, indicates at what percentage of visibility of the target element the callback function is to be executed.

Next, let's explore the callback function. This function gets two arguments, an array of intersection entries and the observer itself. An intersection entry provides information about the intersection change such as the time of intersection, the target element, and also metrics like intersection ratio.

function handleIntersect(entries, observer) {
    entries.forEach((entry) => {
        // logic here

Best practices recommend defining severable the Intersection Observer and callback. As a typical pitfall, some developers include the code of unobserving (unobserve()) the target from within the callback function itself. However, this may lead to a memory leak due to unused observers. Thus, always ensure to unobserve any element no longer required to be tracked. Secondly, ensure your threshold and rootMargin are appropriately set. Setting the threshold array to include 0 can lead to multiple rapid calls to the callback function, countering performance optimizations.

Exploiting Intersection Observer API for pragmatic use-cases: lazy loading and scroll events

The Intersection Observer API provides a simple, yet effective approach for managing scroll events, including the implementation of lazy loading for elements such as images. This API has the unique ability to accurately track when an element appears within the viewport, eliminating the need for complex calculations or cumbersome event handlers. But how do you put it to use in practical examples, such as image lazy loading?

Consider an HTML page with several images. To optimize loading times, you might want to postpone loading of images until they are needed. This can be achieved by placing the source of the images in the data-src attribute rather than the src attribute as shown in this code snippet:

 <img class='js-lazy-image' data-src='directory/my-image.png'>

This setup allows you to create an Intersection Observer that keeps tabs on your images and triggers loading as they come into the viewport. The following code block demonstrates how to create this observer:

var options = {
 rootMargin: '100px 0px'

// Creating an Intersection Observer
var observer = new IntersectionObserver((entries, observer) => {
    // Looping through all entries
    entries.forEach(entry => {
        // If entry is intersecting viewport
            const img =;
            let newImg = new Image();
            newImg.src = img.getAttribute('data-src');
            observer.unobserve(img);  // Stop observing the current image
}, options);

In this observer, we've set our rootMargin as '100px 0px' implying that the observer will start loading the images 100px before they come into the viewport, leading to a more fluid user experience as images get pre-loaded just as the user scrolls to them.

While the Intersection Observer API can significantly enhance the performance of your web pages, it comes with certain limitations. For instance, executing long-running or resource-intensive tasks in the observer’s event handler may block other tasks in the event loop, given that it runs on the main thread. Also, compatibility with legacy environments can still be challenging. Therefore, developers need to meticulously evaluate the constraints and benefits of this API and implement it in accordance with their project's specific requirements.

To evoke further thought on this topic, consider these questions: How would you ensure that all images on a webpage are being observed? What strategies could be employed for timely image loading to maintain a smooth user interaction? Can you imagine other use-cases for the Intersection Observer API in the sphere of modern web development?

Debunking misconceptions and common mistakes in utilizing Intersection Observer API

One common misconception that developers have when using the Intersection Observer API is that it is synchronous, like traditional scrolling or resizing events. This is incorrect. The Intersection Observer API operates asynchronously and does not block the main JavaScript thread, which significantly improves performance. Understanding the differences between synchronous and asynchronous operation is essential in selecting the appropriate tool for visibility monitoring tasks and could play a significant role in enhancing your application performance.

Misuse of the observer disconnect method is another frequent error. Typically, developers may forget to invoke the disconnect() or unobserve() methods when no longer required, causing unnecessary memory consumption. Utilizing these methods appropriately helps to preserve memory especially in extensive applications where resources are precious. Therefore, always make sure to disconnect the observer when no longer needed:

let observer = new IntersectionObserver(callback, options);

// later in the code 
observer.disconnect(); // or observer.unobserve(target);

Another common mistake when using the Intersection Observer API is not correctly defining the root, rootMargin, and threshold options during its initiation. For instance, assuming the root option defaults to the document's viewport -- it actually defaults to null. Misinterpretation of these options could lead to erratic API behavior. It is essential to thoroughly understand these options to effectively utilize the Intersection Observer API as they directly control the observer's behavior.

Lastly, developers often perceive Intersection Observer API merely as a tool for lazy-loading. While it's a great feature, the API is not limited to this. It is an extremely versatile tool capable of being integrated in infinite scenarios. How about using it to trigger animations or load more data as the user scrolls towards the end of a list? Let's challenge the status quo and think beyond the obvious to fully exploit the capabilities of Intersection Observer API.


In this article, we explored the Intersection Observer API and its role in modern web development practices. We compared it to traditional event-driven methods and highlighted its advantages in terms of performance and simplicity. We also discussed the mechanics of the API and provided examples of how to use it for lazy loading and scroll events. A key takeaway is the importance of understanding both approaches and choosing the most appropriate method based on compatibility and performance constraints. As a challenge, readers are encouraged to think of other use-cases for the Intersection Observer API in modern web development beyond lazy loading, such as triggering animations or loading more data as the user scrolls.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers