JavaScript Document afterscriptexecute Event

Beginner
5 min read
Updated: Nov 2026
3 examples
Event

Definition

In JavaScript, the Document afterscriptexecute event once fired when a static <script> finished executing (MDN). It does not fire for scripts added dynamically (for example with appendChild()).

Register a listener with addEventListener. Check readiness and browser support before you rely on this event.

Syntax

Listen for afterscriptexecute. Start with this line.

JavaScript
addEventListener("afterscriptexecute", fn)
CallWhat it does
addEventListener("afterscriptexecute", fn)Primary signature.

Built into the browser. Listen with document.addEventListener("afterscriptexecute", …) — no import required.

Library declarations
JavaScript
addEventListener("afterscriptexecute", fn)

Parameters

ParameterDescription
Static <script>Required. Dynamic scripts were skipped (MDN)
Modern pathRequired. script load / error

Return Value

Return ValueDescription
*Fires as a Document event (listener receives the Event object).

JavaScript Examples

Example 1 — addEventListener("afterscriptexecute")

MDN style: listen on document and read the finished script’s id (legacy Firefox only).

JavaScript
function finished(e) {
  console.log(`Finished script with ID: ${e.target.id}`);
}

document.addEventListener("afterscriptexecute", finished);
console.log("Listener attached (may never fire today)");
Try It Yourself

How It Works

  1. Define a handler. finished logs event.target.id when the event fires.
  2. Register on document. Same pattern as any DOM event via addEventListener.
  3. Expect silence today. Most browsers never dispatch this event.
  4. When it did fire. event.target was the static <script> that just finished.

Example 2 — Feature Detection

Never assume the event exists. Check before you depend on it.

JavaScript
const supported = "onafterscriptexecute" in document;
console.log("onafterscriptexecute in document:", supported);

if (supported) {
  document.addEventListener("afterscriptexecute", () => {
    console.log("Legacy path: afterscriptexecute");
  });
} else {
  console.log("Use script load/error events instead");
}
Try It Yourself

How It Works

  1. Probe the handler property. "onafterscriptexecute" in document is a rough signal.
  2. Branch safely. Only register the legacy listener when the property exists.
  3. Fallback path. Otherwise print the portable advice: use load / error.
  4. Still prefer modern APIs. Even if the property exists, engines may not dispatch the event.

Example 3 — Prefer script load

Portable pattern: listen on the script element you create (works for dynamic scripts too).

JavaScript
const script = document.createElement("script");
script.textContent = "window.__demoRan = true;";

document.body.appendChild(script);

console.log("Prefer load/error over afterscriptexecute");
console.log("after append, __demoRan:", window.__demoRan === true);

// External scripts (usual production case):
// script.src = "/libs/helper.js";
// script.addEventListener("load", () => console.log("executed"));
// script.addEventListener("error", () => console.error("failed"));
// document.head.appendChild(script);
Try It Yourself

How It Works

  1. Create a script node. Inline text runs as soon as you append it.
  2. Append to the document. The browser executes the script immediately.
  3. Confirm the side effect. window.__demoRan becomes true.
  4. For external files. Set src and listen for load / error — the cross-browser replacement.

Browser Support

afterscriptexecute is a Deprecated and Non-standard Gecko Document event (MDN). Other engines never implemented it; modern Firefox no longer dispatches it to web content.

✓ Deprecated · Non-standard

Document afterscriptexecute

Legacy Firefox-only static-script finish event — do not build features on it.

Legacy Not for new apps
Google Chrome Never implemented
Unavailable
Mozilla Firefox Legacy only · removed / disabled in modern versions
Avoid
Apple Safari Never implemented
Unavailable
Microsoft Edge Never implemented (Chromium)
Unavailable
Opera Never implemented (Chromium)
Unavailable
Internet Explorer No afterscriptexecute support
Unavailable
afterscriptexecute Deprecated

Bottom line: Recognize it in old Gecko code, then migrate. Prefer script load/error events or ES modules. Remember: even historically, dynamically appended scripts did not fire this event.

Frequently Asked Questions

A proprietary Gecko (Firefox) Document event that fired after a static <script> finished executing. MDN marks it Deprecated and Non-standard. It was never a finished web standard.
No. MDN: it does not fire when a script element is added dynamically (for example with appendChild()). It only applied to static scripts in the markup in supporting legacy Firefox.
No. Prefer portable APIs such as the script element’s load and error events, ES modules, or MutationObserver when you need to watch scripts being inserted.
Historically only Firefox (Gecko). Chrome, Safari, and Edge never shipped it. Modern Firefox stopped dispatching it to web content.
In supporting legacy Firefox: document.addEventListener("afterscriptexecute", handler) or document.onafterscriptexecute = handler. Always feature-detect; do not assume the event exists.
A generic Event. There is no special payload beyond a normal Event object. Related learning: Document.currentScript and the sibling beforescriptexecute event.

Next: beforescriptexecute

Learn the sibling legacy event that fired before a static script ran (and could cancel it).

beforescriptexecute tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

11 people found this page helpful