Unlocking Advanced Features in Django with HTMX

Patryk Młynarek - Backend Engineer

Patryk Młynarek

11 January 2024, 10 min read

thumbnail post

What's inside

  1. Content Replacement with hx-swap-oob
  2. Triggering Events on the Fly
  3. Automatic Initialization with hx-trigger=load
  4. Streamlined File Uploads
  5. Real-Time Communication with Websockets
  6. Adding Elegance with Animations and Transitions
  7. Automatic Data Refresh with Pooling
  8. Request Indicators for User Feedback
  9. Handling Request and Response Status Codes
  10. Request Order of Operations
  11. Enhancing the Repository with Extra Technologies
  12. Conclusion
  13. Helpful resources
  14. Contact Us


Django is a powerful and flexible web framework, and when combined with HTMX, it becomes a dynamic duo for creating modern web applications. While you may already be familiar with basic HTMX features like hx-get, hx-post, and other basic usage, there's a whole world of advanced functionality waiting to be explored. In this article, we'll delve into some of the more sophisticated features of HTMX that can take your web development to the next level.

Note: Would you prefer to get hands-on with the code immediately? You can find a fully working example in our GitHub repository.

Content Replacement with hx-swap-oob

Another advanced option for manipulating content with HTMX is to make use of the "Out Of Band" hx-swap-oob content support feature. When HTMX receives a response from the server, it scans the response for top-level content that includes the hx-swap-oob attribute. This content is then extracted from the response and won't be inserted into the DOM in the usual way. Instead, it is swapped with the content that matches its specified markup id.

Consider a scenario where you want to provide user-friendly feedback upon form submission without reloading the entire page, and the element you wish to update is located outside the form element. In this example, we'll utilize hx-swap-oob to accomplish this.

<form id="myForm" hx-post="/save-data">
    <input type="text" name="data" placeholder="Enter data">
    <button type="submit">Save</button>
<div id="alerts" hx-swap-oob="true">

In order to illustrate the usage of hx-swap-oob in a practical context, let's take a look at a specific example. You can find the code for this example in the repository, which includes a template named table_products_list.html

Within table_products_list.html, there is a table and an additional element that will be swapped if an AJAX request is performed by HTMX. This element is identified by the span tag with the id attribute set to products-list-counter and the hx-swap-oob attribute, like this: <span id="products-list-counter" hx-swap-oob="true">{{ page_obj.number }}</span>.

The products-list-counter element is initialized by a separate template named products_counter.html

Triggering Events on the Fly

HTMX enables you to trigger events on elements as part of a response. These events can update the page, perform actions, or interact with JavaScript libraries. For example, you can use hx-trigger="my-event to fire a custom event when a response is received.

  <div hx-get="/example" hx-trigger="my-event from:body">
    Triggered by HX-Trigger header...

The event trigger is passed via the response from the server, typically in the response header labeled HX-Trigger. For example, the response header HX-Trigger can equal my-event

Now, let's delve into a practical implementation found in our repository. We have a template named product_random_event.html, which contains the following line of code:

  hx-trigger="{{ htmx_triggers.products_list_page_changed }} from:body"
  <!-- Content here -->

This line instructs the template to respond to a custom event named products_list_page_changed when the server response is received. The magic happens on the server side. Specifically, in the AJAX view class TableProductsListAjax (you can view the actual code here), we set the response header HX-Trigger to HTMXTriggers products_list_page_changed.value.

Automatic Initialization with hx-trigger=load

hx-trigger="load" is a special attribute that triggers a request as soon as the page loads. This can be useful for preloading data or initializing your page with dynamic content without user interaction.

<div hx-get="/initial-data" hx-trigger="load">
    <!-- Content to load on page load -->

Utilizing hx-trigger=load is a strategic move for optimizing user experience by delivering essential content instantly. However, HTMX provides additional triggers that allow for even more dynamic behavior:

  • revealed Trigger: This trigger fires once when an element first scrolls into the viewport. It's valuable for loading content as the user scrolls, enhancing performance and responsiveness. To use it, simply set hx-trigger=revealed.

  • intersect Trigger: Similar to revealed trigger, fires once when an element first intersects the viewport. This trigger is handy when you want to trigger actions based on an element becoming visible. You can also set the percentage of the element that needs to be visible, e.g., 80% before the request is triggered. Use it by setting hx-trigger=intersect.

Now, let's delve into a practical example from our code. In the product_random.html template in our repository, you can find the following line of code:

  hx-trigger="load delay:3s"
  <!-- Content to be loaded -->

This specific usage of hx-trigger demonstrates how the request istailwi triggered with delay when the page is loaded. Additionally, once the first response is received by HTMX, a delay of 3 seconds is applied before the subsequent requests are triggered at 3-seconds intervals. This allows for a controlled and consistent loading of content, ensuring that requests are made at a regular pace after the initial load.

Streamlined File Uploads

HTMX allows for easy file uploads through forms. You can use standard HTML forms with the hx-encoding attribute set to multipart/form-data HTMX seamlessly handles ile uploads, making it straightforward to implement file upload functionality in your Django applications.

Here's an example of an HTML form that works perfectly with Django forms:

<form hx-post="/upload" enctype="multipart/form-data">
    <input type="file" name="file">
    <button type="submit">Upload</button>

For a real-life example, you can explore our repository's template named car_create.html (available here). This template demonstrates how to create a file upload form using HTMX and Django.

Real-Time Communication with Websockets

Integrating Websockets with Django and HTMX allows real-time communication between clients and the server. You can use libraries like Django Channels and HTMX websockets extension to handle it. Implementing a simple chat application is a great way to explore this feature.

Websockets are a game-changer for creating interactive, real-time applications like chats, notifications, and collaborative tools, all while maintaining the Django backend.

You can find a fully working example here in a carefully prepared repository by Sunscrapers.

Adding Elegance with Animations and Transitions

HTMX provides a way to add smooth transitions to your content updates. You can use CSS animations and transitions to make the user experience more engaging and visually appealing.

The most popular approaches are:

Automatic Data Refresh with Pooling

HTMX's pooling feature allows you to refresh content at specified intervals automatically. This is especially useful for near real-time updates, live feeds, and dashboards.

<div hx-get="/live-feed" hx-trigger="every 2s">
    <!-- Content to be refreshed every 2 seconds -->

Pooling is a valuable tool for keeping your web application's data up-to-date, making it suitable for live data, stock market updates, or any real-time information.

In our repository, you can find a concrete implementation of this feature in the template named live_data_dashboard.html. This template, available here, showcases how to create a dynamic dashboard with automatic data refresh every 2 seconds.

Request Indicators for User Feedback

HTMX makes it easy to add request indicators that provide users with feedback during ongoing actions. These indicators can be styled to match your application's design.

When you initiate an action, such as an AJAX request, you can use the htmx-indicator class to create visual feedback. By default, elements with this class are hidden, but when HTMX issues a request (by adding the htmx-request class to an element), elements with the htmx-indicator class become visible. This subtle transition informs users that a request is in progress.

For example, you can use this code snippet to implement a request indicator:

<button hx-get="/click">
    Click Me!
    <img class="htmx-indicator" src="/spinner.gif">

Clicking the button triggers an AJAX request, and the htmx-indicator class displays the spinner GIF, showing users that something is happening. You can also customize the indicator, including using SVG spinners.

Handling Request and Response Status Codes

HTMX can handle different HTTP status codes the server returns, allowing you to respond to errors or specific situations appropriately. For instance, you can customize error messages or handle redirections.

  • 204 - No Content - HTMX will ignore the content of the response
  • Error response (e.g., a 404 or a 501) - HTMX will trigger the htmx:responseError event, which you can handle
  • Connection error - HTMX will trigger the htmx:sendError event.

To implement error handling in HTMX, you can register event listeners in your JavaScript code. For example, here's how you can handle htmx:responseError by updating an element with an error message:

document.getElementById('form').addEventListener('htmx:responseError', function(evt) {
    document.getElementById('error').innerHTML = evt.detail.error;

Handling status codes gives you fine-grained control over how your application responds to various scenarios, making it robust and user-friendly.

Request Order of Operations

HTMX processes requests in a well-defined order of operations, ensuring that each step is executed efficiently and systematically. Understanding this sequence is essential for building responsive and dynamic web applications. Let's break down the order of operations in an HTMX request:

The order of operations in a htmx request are:

  • The element is triggered and begins a request
    • Values are gathered for the request
    • The htmx-request class is applied to the appropriate elements
    • The request is then issued asynchronously via AJAX
      • Upon getting a response the target element is marked with the htmx-swapping class
      • An optional swap delay is applied (see the hx-swap attribute)
      • The actual content swap is done
      • the htmx-swapping class is removed from the target
      • the htmx-added class is added to each new piece of content
      • the htmx-settling class is applied to the target
      • A settle delay is done (default: 20ms)
      • The DOM is settled
      • the htmx-settling class is removed from the target
      • the htmx-added class is removed from each new piece of content

You can use the htmx-swapping and htmx-settling classes to create CSS transitions between pages.

Enhancing the Repository with Extra Technologies

While HTMX takes the spotlight in our journey to unlock advanced features in Django, our testing repository doesn't stop at just one tool. We've enlisted the help of two additional technologies to enrich your development experience.

Flowbite: Fueling UI Development

Flowbite is a game-changer for UI development. It's an open-source collection of UI components constructed with Tailwind CSS utility classes. Flowbite serves as a robust foundation when crafting user interfaces and websites. It offers a wide range of ready-made components, including alerts, badges, breadcrumbs, and buttons, making it an ideal starting point for your UI projects.

In our testing repository, we've incorporated Flowbite components to demonstrate how you can elevate the visual appeal of your Django applications. Flowbite's UI components work harmoniously with HTMX to enhance your web interfaces, ensuring that they not only function seamlessly but also look exceptional.

Django Channels: Real-Time Capabilities

Django Channels, or simply Channels, extends the capabilities of Django beyond the realms of traditional HTTP requests. It introduces support for long-running connections, real-time protocols, and more. Whether you're working on a live chat system, IoT dashboard, or any real-time application, Django Channels is your gateway to adding real-time interactivity.

Our testing repository showcases how Django Channels integrates with HTMX to empower your Django applications with real-time functionality. By combining these two technologies, you can deliver live data updates and interactive features, enriching the user experience with real-time capabilities.


Django with HTMX is a potent combination that can help you build advanced web applications with minimal effort. Whether you're looking to create a real-time chat application, implement animations, or work with Websockets, HTMX's advanced features provide the tools you need to craft modern, interactive, and efficient web experiences.

So, go ahead and explore the limitless possibilities of Django and HTMX, and take your web development skills to the next level. Happy coding!

Helpful resources

Contact Us

Our team is at the forefront of innovation, and we're here to help you navigate the complexities of the digital world. Don't hesitate to contact us today, and let's craft solutions that propel you forward.

Patryk Młynarek - Backend Engineer

Patryk Młynarek

Backend Engineer

Patryk is a experienced Senior Python Developer who puts business value on the first place. Web applications enthusiast from initial development to server maintenance, ensuring the entire process runs smoothly. In his free time, Patryk enjoys playing board games and motorcycling.




Recent posts