jQuery getScript() Method

What You’ll Learn

$.getScript() is jQuery’s dedicated JavaScript GET shorthand. This tutorial covers the official signature, how it maps to $.ajax() with dataType: "script", global script execution after load, the success callback fired only after execution completes, default cache: false timestamp behavior, the official $.cachedScript() wrapper, chaining .done() and .fail() on the returned jqXHR, jQuery 3.5.0 HTTP error semantics, and when to upgrade to full $.ajax().

Introduction

Not every library belongs in your HTML on first paint. Color animation plugins, charting libraries, and date utilities are often loaded on demand — when a user opens a panel, clicks a button, or scrolls to a widget. jQuery makes that one line with $.getScript(). Pass a URL and an optional callback; jQuery sends an asynchronous HTTP GET request, injects the response as executable JavaScript in the global context, and invokes your function once the script has loaded and run.

Under the hood, $.getScript() is not a separate transport — it is a thin wrapper around jQuery.ajax() with dataType: "script" preset and cache defaulting to false. That means you inherit the same jqXHR return value, global Ajax events on document, and Promise-style chaining. When your needs outgrow a one-liner — cached production loads, custom headers, or global: false — you drop down to $.ajax() or the official $.cachedScript() pattern without changing mental models.

Understanding jQuery.getScript()

jQuery.getScript() loads a JavaScript file from a server using an HTTP GET request, then executes it. The method returns immediately with a jqXHR object while the network call runs in the background. If you pass a success function, jQuery calls it only after the script body has been retrieved, evaluated, and executed — not merely downloaded.

Because execution happens in the global context, loaded scripts can define functions, attach plugins to jQuery.fn, and reference variables already on window. That power comes with responsibility: only load scripts from origins you trust. A malicious response runs with full page privileges.

📝 Syntax

The official jQuery API accepts one signature:

Positional arguments — jQuery.getScript( url [, success ] )

jQuery.getScript( url [, success ] )

URL first, optional success callback. Unlike $.get(), there is no data argument — script requests load a file by URL only.

Equivalence to $.ajax()

These two calls are identical:

// Shorthand
$.getScript( url, success );

// Expanded — what jQuery does internally
$.ajax( {
  url: url,
  dataType: "script",
  success: success
} );

success callback signature

• script — the raw script text returned by the server (same as the first argument historically named data in API docs).
• textStatus — string such as "success" when the request completes without transport errors.
• jqXHR — the same jqXHR object returned by $.getScript(); inspect jqXHR.status for the HTTP status code.

Return value

• $.getScript() returns a jqXHR object — chain .done(), .fail(), and .always().
• The success callback fires after the script is loaded and executed — globals defined by the file are available when your callback runs.
• Deprecated jqXHR methods .success(), .error(), and .complete() were removed in jQuery 3.0 — use .done() / .fail() / .always().
• Call jqXHR.abort() to cancel an in-flight script request before it completes.

Examples Gallery

Five progressive examples from a basic CDN utility load through global library usage, jqXHR error handling, the official $.cachedScript() pattern, and side-by-side equivalence with $.ajax({ dataType: "script" }). Each links to a Try-it lab where you can edit and run the code in the browser.

$( "#load" ).on( "click", function() {
  $.getScript(
    "https://cdn.jsdelivr.net/npm/dayjs/dayjs.min.js",
    function( script, textStatus, jqXHR ) {
      // dayjs is now on window — script has loaded AND executed
      var today = dayjs().format( "MMMM D, YYYY" );
      $( "#result" ).html(
        "<strong>Today:</strong> " + today +
        " <small>(" + textStatus + ", HTTP " + jqXHR.status + ")</small>"
      );
      console.log( typeof dayjs ); // "function"
    }
  );
} );

User clicks #load → $.getScript() GETs dayjs.min.js from jsDelivr

Script injected and executed → dayjs() available globally

#result shows "Today: July 18, 2026 (success, HTTP 200)"

var lodashUrl = "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js";

$.getScript( lodashUrl, function() {
  // _ is now on window — defined by the loaded script
  var version = _.VERSION;
  var doubled = _.map( [ 1, 2, 3 ], function( n ) {
    return n * 2;
  } );

  $( "#lib-info" ).html(
    "<strong>lodash</strong> v" + version +
    " loaded — _.map([1,2,3]) → [" + doubled.join( ", " ) + "]"
  );
} );

GET lodash.min.js from cdnjs → script executes in global context

_.VERSION available → #lib-info shows "lodash v4.17.21 loaded"

_.map([1,2,3]) → [2, 4, 6] displayed in the result

function loadPlugin( url ) {
  return $.getScript( url )
    .done( function( script, textStatus, jqXHR ) {
      $( "#status" ).text( "Loaded (HTTP " + jqXHR.status + ")" ).css( "color", "green" );
    } )
    .fail( function( jqXHR, textStatus, errorThrown ) {
      $( "#status" ).text(
        "Failed: " + textStatus + " — " + errorThrown + " (HTTP " + jqXHR.status + ")"
      ).css( "color", "red" );
    } );
}

// Valid CDN script
loadPlugin( "https://cdn.jsdelivr.net/npm/dayjs/dayjs.min.js" );

// 404 — triggers .fail()
$( "#load-bad" ).on( "click", function() {
  loadPlugin( "https://cdn.jsdelivr.net/npm/this-library-does-not-exist-xyz/plugin.min.js" );
} );

Valid URL → .done() sets #status green "Loaded (HTTP 200)"

Click #load-bad → GET 404 → .fail() runs

#status shows red "Failed: error — Not Found (HTTP 404)"

Prior to jQuery 3.5.0, some failed script responses still executed

jQuery.cachedScript = function( url, options ) {
  // Allow user to set any option except for dataType, cache, and url
  options = $.extend( options || {}, {
    dataType: "script",
    cache: true,
    url: url
  } );

  // Use $.ajax() since it is more flexible than $.getScript
  // Return the jqXHR object so we can chain callbacks
  return jQuery.ajax( options );
};

// Usage — browser may reuse cached copy (no timestamp param)
$.cachedScript( "https://cdn.jsdelivr.net/npm/dayjs/dayjs.min.js" )
  .done( function( script, textStatus ) {
    $( "#cached-result" ).text(
      "Cached load: " + textStatus + " — today is " + dayjs().format( "YYYY-MM-DD" )
    );
  } );

$.cachedScript() calls $.ajax({ dataType: "script", cache: true, url })

No _=timestamp query param appended — browser cache honored

.done() shows "Cached load: success — today is 2026-07-18"

var url = "https://cdn.jsdelivr.net/npm/dayjs/dayjs.min.js";

// Approach A — dedicated script shorthand
$.getScript( url, function() {
  $( "#result-a" ).text( "getScript: " + dayjs().format( "HH:mm:ss" ) );
} );

// Approach B — explicit $.ajax() with dataType
$.ajax( {
  url: url,
  dataType: "script",
  success: function() {
    $( "#result-b" ).text( "ajax script: " + dayjs().format( "HH:mm:ss" ) );
  }
} );

// Both expand internally to the same transport:
// GET url → inject <script> → execute in global context → success fires

Both requests GET dayjs.min.js with dataType "script"

#result-a and #result-b show the same formatted time

Choose $.getScript() for readability; $.ajax() when you need extra options

🚀 Common Use Cases

• Lazy-load plugins — fetch jQuery UI widgets, color animation, or chart libraries only when a user opens the relevant panel.
• Conditional features — load a mapping SDK when the user navigates to a map view instead of on every page load.
• Third-party widgets — inject chat, analytics, or social embed scripts on demand after consent or interaction.
• A/B test bundles — load variant-specific JavaScript from different URLs based on experiment assignment.
• Admin-only tools — load rich editors or data-grid libraries only for authenticated admin routes.
• Progressive enhancement — keep the initial HTML lean; enhance with script modules as capabilities are needed.

📝 Notes

• $.getScript() is asynchronous — code after the call runs before the script loads and executes.
• It is shorthand for $.ajax() with dataType: "script" — same jqXHR, same global Ajax events.
• Global execution: loaded scripts run in the window context and can modify your page — only load URLs you trust completely.
• Security: never pass user-controlled URLs to $.getScript(); treat dynamic script loads like eval() from a remote source.
• Cache default: cache: false appends a timestamp query param — use $.cachedScript() or $.ajaxSetup({ cache: true }) for stable CDN URLs.
• Success timing: the callback fires after load and execution — globals defined by the file exist when your callback runs.
• Prefer .done() / .fail() / .always() over deprecated jqXHR .success() / .error() / .complete() (removed in jQuery 3.0).
• jQuery 3.5.0+: unsuccessful HTTP responses with script Content-Type are no longer executed — upgrade for safer error semantics.

💡 Best Practices