ownerDocument?node.ownerDocument returns the top-level Document that owns the node (MDN). On a normal page element that is usually the same object as the global document. On a Document itself, it is null.
Status: Baseline Widely available (since July 2015) — not Deprecated, Experimental, or Non-standard. Read-only — you inspect ownership; you do not assign to it.
node.ownerDocument
→ Document that owns the node
→ or null when node is itself a Document
Page element:
el.ownerDocument === document → true
Document:
document.ownerDocument → null
Owned ≠ connected:
createElement(...) still has ownerDocument
isConnected may still be false| Goal | Prefer |
|---|---|
| Owning Document | node.ownerDocument |
| Immediate parent | node.parentNode |
| In the live tree? | node.isConnected |
ownerDocumentRead the owning document, then use it to create nodes or reach documentElement.
node.ownerDocument.createElement / documentElement.null.| Piece | Required? | Role |
|---|---|---|
node | Yes | Any DOM Node |
| Return | — | Document, or null for Document nodes |
| Null check | If unsure | Needed when the node might be a Document |
doc = node.ownerDocument
if doc is null:
// node is a Document
else:
html = doc.documentElement
el = doc.createElement("span")
// MDN-style climb:
d = p.ownerDocument
html = d.documentElement
// iframe-safe create:
doc = referenceNode.ownerDocument
sibling = doc.createElement("span")Keep these facts handy when working across documents.
| Topic | Detail |
|---|---|
| Syntax | node.ownerDocument |
| Returns | Document or null |
| Mutates? | No — read-only |
| On Document | Always null (MDN) |
| Before append | Still set after createElement |
| vs parentNode | Owner document vs immediate parent |
| Standard | Baseline Widely available (since July 2015) |
Compare ownerDocument on an element, the document itself, and a newly created node.
Short, copy-ready snippets based on MDN Node.ownerDocument. Use Try It Yourself for a live editor.
On a normal page, an element’s owner is the global document.
const p = document.getElementById("demo");
console.log(p.ownerDocument === document); // true
console.log(p.ownerDocument.nodeName); // "#document"document.ownerDocument Is nullMDN: on a node that is itself a document, the value is null.
console.log(document.ownerDocument); // null
console.log(document.nodeType === Node.DOCUMENT_NODE); // trueDOCUMENT_NODE.null.documentElement (MDN-style)From any node, climb to the owning document, then to <html>.
const p = document.getElementById("demo");
const d = p.ownerDocument;
const html = d.documentElement;
console.log(html.nodeName); // "HTML"p.ownerDocument.<html> element.document.Ownership is set at creation, even before append.
const el = document.createElement("div");
console.log(el.ownerDocument === document); // true
console.log(el.parentNode); // null
console.log(el.isConnected); // falseparentNode is null.isConnected stays false until append.Prefer the node’s owner when building related elements (iframe-safe habit).
function makeSpanNextTo(node, label) {
const doc = node.ownerDocument;
const span = doc.createElement("span");
span.textContent = label;
node.parentNode.appendChild(span);
return span;
}
const demo = document.getElementById("demo");
const span = makeSpanNextTo(demo, " sibling");
console.log(span.ownerDocument === demo.ownerDocument); // truedocument.Check these before assuming every node shares the global document.
MDN: if the node is itself a document, ownerDocument is null. Null-check before calling methods on the result.
A node from createElement has an owner immediately, but isConnected stays false until you append it.
In multi-document setups, create with node.ownerDocument.createElement so new nodes match the reference node’s document.
parentNode is the immediate parent. ownerDocument is the Document that owns the node for its whole lifetime in that document.
Node.ownerDocument is marked Baseline Widely available on MDN (since July 2015).
Returns the Document that owns a node, or null when the node is itself a Document. Read-only. Safe for everyday DOM work and iframe-aware helpers.
Bottom line: Safe everyday DOM API. Remember Document → null. See the MDN ownerDocument reference.
| Approach | Cost | Best for |
|---|---|---|
node.ownerDocument | O(1) | Find owning Document |
Climb via parentNode to root | O(depth) | Avoid — use ownerDocument |
getRootNode() | O(depth) typical | Shadow roots / composed trees |
Reading ownerDocument is cheap. Prefer it over walking parents when you only need the Document. For shadow DOM roots, also know getRootNode().
appendChild.node.ownerDocument.createElement(...).One line: ownerDocument is the Document that owns a node — null on Document itself, and set even before the node is connected.
Learn how to read the parent element of a node (or null).
9 people found this page helpful