Ajax in WordPress: Code Examples

A. Overview of Ajax in WordPress

Ajax, which stands for Asynchronous JavaScript and XML, is a powerful technique that allows websites to send and receive data asynchronously without reloading the entire page. In the context of WordPress, Ajax plays a crucial role in creating dynamic and interactive web experiences. It enables developers to build responsive interfaces, implement real-time updates, and enhance user interactions without disrupting the overall browsing experience.

B. Importance of Ajax for dynamic and interactive web development

Ajax has become an essential tool for modern web development, including WordPress websites. It offers numerous benefits that greatly improve the user experience and functionality of a website. Some of the key reasons why Ajax is important in WordPress development are:

  • Enhanced User Experience: Ajax enables seamless and instant content updates, eliminating the need for page reloads. This results in a smoother browsing experience for users as they can interact with the website without interruptions.
  • Real-Time Updates: With Ajax, WordPress developers can implement real-time updates, such as live chat features, dynamic form validation, or instant search suggestions. This real-time interaction keeps the website up to date and engaging for users.
  • Improved Performance: By fetching data asynchronously, Ajax reduces server load and minimizes bandwidth consumption. This leads to faster response times and improved website performance, which is crucial for user satisfaction and search engine optimization.
  • Interactive User Interfaces: Ajax allows developers to create interactive and intuitive user interfaces by adding features like drag-and-drop functionality, sortable lists, and dynamic content loading. These enhancements make the website more engaging and user-friendly.
  • Seamless Data Retrieval: Ajax enables WordPress websites to fetch data from external APIs or the WordPress database without refreshing the page. This capability is particularly useful for displaying dynamic content, retrieving additional information, or populating forms with relevant data.

1. Writing the PHP Code

A. add action hook for processing the Ajax request

To handle Ajax requests in WordPress, you need to utilize two action hooks: wp_ajax_{your_action} and wp_ajax_nopriv_{your_action}. The wp_ajax_{your_action} hook is used for authenticated users, while the wp_ajax_nopriv_{your_action} hook is used for non-authenticated users. By implementing both hooks, you can ensure that your Ajax functionality works seamlessly for all types of users, whether they are logged in or not.

add_action( 'wp_ajax_my_ajax_action', 'my_ajax_callback' );
add_action( 'wp_ajax_nopriv_my_ajax_action', 'my_ajax_callback' );

Here, my_ajax_action is a unique identifier for your Ajax action, and my_ajax_callback is the function that will be executed when the Ajax request is made.

B. Defining the callback function in WordPress

To create an Ajax endpoint in WordPress, you need to define a callback function that will handle the Ajax request. This function will be executed when the Ajax call is made. Here’s an example of how you can define the callback function:

function my_ajax_callback() {

    // verify the nonce.
    $nonce = isset($_POST['nonce']) ? $_POST['nonce'] : '';
    if( !wp_verify_nonce( $nonce, 'ajax_nonce' ) ) {
        wp_send_json_error( __( 'Refresh the page and try again', 'text_domain' ) );

    // do stuff here
    $data  = $_POST['data'] ?? '';
    $data  = sanitize_text_field( $data );
    $error = false;

    // return a response
    if ( $error ) {
        wp_send_json_error( __( 'Error!', 'text_domain' ) );

    wp_send_json_success( __( 'Success!', 'text_domain' ) );

Note: Validate and sanitize data received from the Ajax request to ensure security and integrity.

C. Enqueue and Localize script

To ensure proper functionality, it is important to enqueue the script and localize the Ajax URL and the nonce. Enqueuing the script allows WordPress to handle the loading and dependencies of the script efficiently. Localizing the Ajax URL and the nonce ensures secure and reliable communication between the client-side JavaScript and the server-side callback function. Here’s how you can accomplish this:

add_action( 'wp_enqueue_scripts', function(){

    // Enqueue script
    wp_enqueue_script( 'my_script', get_template_directory_uri() . '/script.js', array(), '1.0.0', true );

    // Localize script
    wp_localize_script( 'my_script', 'my_script_vars', array(
        'ajax_url' => admin_url( 'admin-ajax.php' ),
        'nonce'    => wp_create_nonce( 'my_script_nonce' )


2. Writing the JavaScript Code

// Add event listener to a button
document.querySelector('#my-button').addEventListener( 'click', makeAjaxCall );

// Function to make Ajax call
function makeAjaxCall( e ) {

    let formData    = new FormData();
    formData.append( 'action', 'my_ajax_action' );
    formData.append( 'nonce', my_script_vars.nonce );

    let requestOptions = {
        method: 'POST',
        body: formData,
        redirect: 'follow'

    fetch(my_script_vars.ajax_url, requestOptions) // Make the Ajax call to the specified URL
    .then(response => response.json()) // Convert the response to JSON format
    .then(result => {

        if ( result.success ) {

            // do something
            console.log( result.data );

        } else {

            // show error message
            console.log( result.data );

    .catch(error => {
        console.log( 'ERROR: ', error );