jQuery .ajaxSend() Method

What You’ll Learn

The .ajaxSend() method is jQuery’s legacy shorthand for binding global ajaxSend handlers on document. This tutorial covers $(document).ajaxSend(handler), the handler signature (event, jqXHR, ajaxOptions), why binding must target document since 1.9, migration to .on("ajaxSend") and cleanup with .off("ajaxSend"), and why the method is deprecated since jQuery 3.5. Unlike .click(), there is no trigger variant — only binding. The handler fires before the request is sent. For the modern ajaxSend event API, see the jQuery ajaxSend event tutorial.

Introduction

Before jQuery 1.7 unified events with .on() and .off(), global Ajax events had matching shorthand methods — .ajaxStart(), .ajaxSend(), .ajaxComplete(), and others. The .ajaxSend(handler) method let you register a page-wide “request about to leave” callback in one short call: $(document).ajaxSend(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 .ajaxSend() matters when reading older admin panels, legacy jQuery plugins, and tutorials written before .on("ajaxSend") became standard. Unlike DOM event shorthands such as .click(), .ajaxSend() has only a binding form — there is no no-argument trigger variant. The handler runs just before the HTTP request is dispatched — ideal for global loading indicators or debug logging. Modern jQuery binds the same global event explicitly: $(document).on("ajaxSend", handler). This page documents the shorthand API and shows how to migrate.

Understanding the .ajaxSend() Method

The official jQuery API describes .ajaxSend() as a way to register a handler to be executed before an Ajax request is sent. When you pass a function, jQuery registers it on document and calls it just before every qualifying Ajax request leaves the browser. That is the same ajaxSend global event that .on("ajaxSend") handles today.

The handler receives three arguments even though the API signature lists only handler: event (the jQuery event object), jqXHR (the XMLHttpRequest wrapper), and ajaxOptions (the settings object passed to $.ajax() — compare ajaxOptions.url to identify the request). Requests with global: false opt out — they do not trigger .ajaxSend() handlers.

📝 Syntax

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

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

$( document ).ajaxSend( handler )

• handler — function invoked before any qualifying Ajax request is sent. Official docs list Function(); the callback actually receives function( event, jqXHR, ajaxOptions ) { ... }.
• Must attach to document since jQuery 1.9 — not window or other elements.
• Fires before the request leaves the browser — after ajaxStart when applicable.
• Returns the jQuery object (document wrapped) for chaining.
• Modern replacement: $( document ).on( "ajaxSend", handler ).

2. Official jQuery API migration note

// Deprecated binding
$( document ).ajaxSend( function( event, jqXHR, settings ) {
  console.log( "About to send:", settings.url );
} );

// Modern binding
$( document ).on( "ajaxSend", function( event, jqXHR, settings ) {
  console.log( "About to send:", settings.url );
} );

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

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

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

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

Return value

• .ajaxSend(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, filtering by settings.url, a legacy loading indicator, migration from .ajaxSend() to .on("ajaxSend"), and removing handlers with .off(). Use the Try-it links to run each snippet in the browser. Remember: binding with .ajaxSend(handler) is deprecated — these demos show legacy syntax you will encounter in older code.

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

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

User clicks #fetch → ajaxSend fires BEFORE $.get() completes

.log shows handler message immediately when request starts

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

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

var targetUrl = "https://jsonplaceholder.typicode.com/posts/1";

$( document ).ajaxSend( function( event, jqXHR, settings ) {
  if ( settings.url === targetUrl ) {
    $( ".log" ).text( "About to send: " + settings.url );
  }
} );

Request to posts/1 → .log shows "About to send: .../posts/1"

Request to other URLs → handler runs but if-block skipped

Same filtering pattern works with .on("ajaxSend")

$( document ).ajaxSend( function() {
  $( "#status" ).text( "Sending request..." );
} );

$( document ).ajaxComplete( function() {
  $( "#status" ).text( "Request finished." );
} );

Click Fetch → #status shows "Sending request..." immediately

When response arrives → ajaxComplete sets "Request finished."

Pair .ajaxSend() with .ajaxComplete() for simple global spinners

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

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

Both handlers fire when $.get() starts

Legacy message from .ajaxSend(fn)

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

Behavior is identical — only the API name differs

var count = 0;

function onSend() {
  count++;
  $( ".log" ).text( "Handler active — ajaxSend count: " + count );
}

$( document ).ajaxSend( onSend );

$( "#remove" ).on( "click", function() {
  $( document ).off( "ajaxSend", onSend );
  $( ".log" ).text( "Handler removed — count stays " + count + "." );
} );

Run $.get() → count increments before response

Click Remove → .off("ajaxSend", onSend)

Next $.get() starts but handler no longer runs — count unchanged

🚀 Common Use Cases

• Reading legacy code — recognize $(document).ajaxSend(fn) as equivalent to .on("ajaxSend", fn) in older admin panels.
• Global loading spinners — legacy pages show “Sending…” via .ajaxSend() — migrate to .on() when refactoring.
• Debug logging — log outgoing URLs and HTTP methods before requests leave the browser during development.
• URL filtering — compare settings.url inside .ajaxSend(fn) before updating the DOM.
• SPA teardown — remove global handlers with .off("ajaxSend", fn) when unmounting a view.
• Third-party isolation — requests with global: false still opt out of .ajaxSend() handlers.

📝 Notes

• Deprecated since jQuery 3.5 — do not use $(document).ajaxSend(handler) in new code. Use .on("ajaxSend") 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 (event, jqXHR, ajaxOptions) even though the API lists handler as Function().
• Fires before the request is sent — not after the response arrives (ajaxComplete handles that).
• Remove handlers with $(document).off("ajaxSend", handler) — not .unbind("ajaxSend").
• Requests with global: false do not trigger .ajaxSend() handlers.
• For per-request setup, use the beforeSend option in $.ajax() instead of a global handler.
• Legacy code using .ajaxSend() still runs in jQuery 3.x — migrate when you refactor those files.
• For event order, comparison with beforeSend, and the complete modern workflow, see the jQuery ajaxSend event tutorial.

💡 Best Practices