jQuery .ajaxStop() Method

What You’ll Learn

The .ajaxStop() method is jQuery’s legacy shorthand for binding global ajaxStop handlers on document. This tutorial covers $(document).ajaxStop(handler), the handler signature function() with no jqXHR or settings arguments, why binding must target document since 1.9, migration to .on("ajaxStop") and cleanup with .off("ajaxStop"), pairing with ajaxStart for loading UI, and why the method is deprecated since jQuery 3.5. Unlike .click(), there is no trigger variant — only binding. The handler fires when the last global Ajax request completes. For the modern ajaxStop event API, see the jQuery ajaxStop event tutorial.

Introduction

Before jQuery 1.7 unified events with .on() and .off(), global Ajax events had matching shorthand methods — .ajaxStart(), .ajaxSend(), .ajaxComplete(), .ajaxStop(), and others. The .ajaxStop(handler) method let you register a page-wide “last request finishing” callback in one short call: $(document).ajaxStop(function(){ ... }). It has been available since jQuery 1.0 and remains in jQuery 3.x for backward compatibility but is marked deprecated since 3.5.

Understanding .ajaxStop() matters when reading older admin panels, legacy jQuery plugins, and tutorials written before .on("ajaxStop") became standard. Unlike DOM event shorthands such as .click(), .ajaxStop() has only a binding form — there is no no-argument trigger variant. The handler runs when the last qualifying global Ajax request completes — ideal for hiding a page-wide loading spinner. Modern jQuery binds the same global event explicitly: $(document).on("ajaxStop", handler). This page documents the shorthand API and shows how to migrate.

Understanding the .ajaxStop() Method

The official jQuery API describes .ajaxStop() as a way to register a handler to be executed when all Ajax requests have completed. When you pass a function, jQuery registers it on document and calls it when the last qualifying global Ajax request has finished and no others remain active. That is the same ajaxStop global event that .on("ajaxStop") handles today.

The handler receives no arguments — the API lists handler as Function() with no parameters. Unlike ajaxComplete, you do not get jqXHR or settings. Requests with global: false opt out — they do not trigger .ajaxStop() handlers. Pair with .ajaxStart() (or .on("ajaxStart")) to show loading UI when a batch begins and hide it when the last active request finishes.

📝 Syntax

The .ajaxStop() method has one signature from the official jQuery API — binding only. There is no trigger form unlike .click():

1. Bind a handler — .ajaxStop( handler ) (deprecated since 3.5)

$( document ).ajaxStop( handler )

• handler — function invoked when the last global Ajax request completes: function() { ... } — no jqXHR or settings arguments.
• Must attach to document since jQuery 1.9 — not window or other elements.
• Fires only when the active global request count returns to zero.
• Returns the jQuery object (document wrapped) for chaining.
• Modern replacement: $( document ).on( "ajaxStop", handler ).

2. Official jQuery API migration note

// Deprecated binding
$( document ).ajaxStop( function() {
  console.log( "All global Ajax requests completed." );
} );

// Modern binding
$( document ).on( "ajaxStop", function() {
  console.log( "All global Ajax requests completed." );
} );

// Remove handler — use .off(), not .unbind()
$( document ).off( "ajaxStop", myHandler );

3. Unbind — $(document).off("ajaxStop" [, handler])

$( document ).off( "ajaxStop" );              // remove all ajaxStop handlers
$( document ).off( "ajaxStop", myHandler );   // remove one handler

Do not use deprecated .unbind("ajaxStop") in new code. Store a named function reference when you need to remove a specific handler later.

Return value

• .ajaxStop(handler) returns the original jQuery object for chaining.
• Handler return values are ignored by jQuery’s global Ajax event system.

Examples Gallery

Five examples cover basic binding, a legacy loading indicator, parallel requests firing once, migration from .ajaxStop() to .on("ajaxStop"), and removing handlers with .off() paired with .ajaxStart(). Use the Try-it links to run each snippet in the browser. Remember: binding with .ajaxStop(handler) is deprecated — these demos show legacy syntax you will encounter in older code.

$( document ).ajaxStop( function() {
  $( ".log" ).text( "Handler ran via .ajaxStop(function(){ ... })." );
} );

$( "#fetch" ).on( "click", function() {
  $.get( "https://jsonplaceholder.typicode.com/posts/1" );
} );

User clicks #fetch → ajaxStop fires when last request completes

.log shows handler message immediately when all activity stops

Works for $.ajax(), $.get(), $.post(), and .load()

Deprecated — prefer .on("ajaxStop", fn) for new code

$( document ).ajaxStop( function() {
  $( "#loading" ).hide();
} );

$( "#fetch" ).on( "click", function() {
  $.get( "https://jsonplaceholder.typicode.com/posts/1" );
} );

Click Fetch → #loading becomes hidden when all requests finish

Show spinner with .ajaxStart() in a paired handler

Pair .ajaxStop() with .ajaxStart() for simple global spinners

var startCount = 0;

$( document ).ajaxStop( function() {
  startCount++;
  $( ".log" ).text( "ajaxStop fired — count: " + startCount );
} );

$( "#parallel" ).on( "click", function() {
  $.get( "https://jsonplaceholder.typicode.com/posts/1" );
  $.get( "https://jsonplaceholder.typicode.com/posts/2" );
  $.get( "https://httpbin.org/delay/1" );
} );

Click Parallel → three $.get() calls start together

ajaxStop fires once — startCount increments by 1 only after all parallel calls finish

Second click while idle → count goes to 2 (one ajaxStop per batch)

// Legacy — deprecated since jQuery 3.5
$( document ).ajaxStop( function() {
  $( "#out" ).text( "Legacy: .ajaxStop(function(){ ... })." );
} );

// Modern — use for new code
$( document ).on( "ajaxStop", function() {
  $( "#out" ).text( "Modern: .on('ajaxStop', function(){ ... })." );
} );

Both handlers fire when $.get() completes the batch

Legacy message from .ajaxStop(fn)

Modern message from .on("ajaxStop", fn)

Behavior is identical — only the API name differs

var count = 0;

function onStart() {
  $( "#loading" ).show().text( "Loading..." );
}

function onStop() {
  count++;
  $( "#loading" ).hide();
}

$( document ).ajaxStart( onStart );
$( document ).ajaxStop( onStop );

$( "#remove" ).on( "click", function() {
  $( document ).off( "ajaxStop", onStop );
  $( "#loading" ).show().text( "Stop handler removed — count stays " + count + "." );
} );

Run $.get() → #loading shows via .ajaxStart(), then hides via .ajaxStop()

When all requests finish → .ajaxStop() hides #loading, count increments

Click Remove → .off("ajaxStop", onStop)

Next $.get() finishes but onStop no longer runs — count unchanged, spinner may stay visible

🚀 Common Use Cases

• Reading legacy code — recognize $(document).ajaxStop(fn) as equivalent to .on("ajaxStop", fn) in older admin panels.
• Global loading spinners — legacy pages hide #loading via .ajaxStop() — migrate to .on() when refactoring.
• Pair with ajaxStart — show UI on start, hide when the last request finishes — the classic loading-indicator pattern.
• Parallel request batches — one ajaxStop for three simultaneous $.get() calls — no manual counter needed.
• SPA teardown — remove global handlers with .off("ajaxStop", fn) when unmounting a view.
• Third-party isolation — requests with global: false still opt out of .ajaxStop() handlers.

📝 Notes

• Deprecated since jQuery 3.5 — do not use $(document).ajaxStop(handler) in new code. Use .on("ajaxStop") instead. Available since jQuery 1.0.
• Attach to document since jQuery 1.9 — not window or other elements.
• Binding only — no no-argument trigger form unlike .click() or .mousedown().
• Handler receives no arguments — unlike ajaxComplete, there is no jqXHR or settings object.
• Fires when the last global request completes — not after every individual call.
• Remove handlers with $(document).off("ajaxStop", handler) — not .unbind("ajaxStop").
• Requests with global: false do not trigger .ajaxStop() handlers.
• Pair with .ajaxStart() (or .on("ajaxStart")) to show loading UI when a batch begins.
• Legacy code using .ajaxStop() still runs in jQuery 3.x — migrate when you refactor those files.
• For event order, parallel requests, and the complete modern workflow, see the jQuery ajaxStop event tutorial.

💡 Best Practices