JavaScript Document hasRedemptionRecord() Method

What You’ll Learn

document.hasRedemptionRecord() is an instance method that asks whether the browser already has a redemption record from a given issuer (see MDN Document: hasRedemptionRecord()). Learn how it differs from hasPrivateToken(), secure-context rules, exceptions, and safe feature detection.

Introduction

In the Private State Token flow, issuers can mint tokens and later sites can redeem them. After redemption, the browser may store a redemption record. This method answers: do we already have one from issuer X?

MDN: hasRedemptionRecord() returns a promise that fulfills with a boolean indicating whether the browser has a redemption record originating from a particular issuer.

Related tutorials: hasPrivateToken(), hasStorageAccess(), hasFocus().

Understanding document.hasRedemptionRecord()

An instance method on the Document interface from the Private State Token API (MDN). Call it on document.

• issuer — string URL of an issuer server (MDN).
• Return value — a Promise that resolves to a boolean (MDN).
• true — a redemption record from that issuer is stored.
• false — no redemption record for that issuer yet.
• Experimental — limited browser support; feature-detect first (MDN).
• Companion API — often used after tokens exist; see hasPrivateToken().

📝 Syntax

General form of Document.hasRedemptionRecord (MDN):

hasRedemptionRecord(issuer)

Parameters

• issuer — a string representing the URL of an issuer server (MDN). Prefer a full absolute URL such as "https://issuer.example".

Return value

A Promise that resolves with a boolean value indicating whether the browser has a redemption record stored that originates from the specified issuer server (MDN).

Exceptions (MDN)

• InvalidStateError — the current Document is not yet active.
• NotAllowedError — the current Document is not loaded in a secure context.
• TypeError — issuer is not a valid URL.

MDN-inspired sample (instance call)

const hasRR = await document.hasRedemptionRecord("https://issuer.example");
if (hasRR) {
  await fetch("https://some-resource.example/", {
    method: "POST",
    privateToken: {
      version: 1,
      operation: "send-redemption-record",
      issuers: ["https://issuer.example"],
    },
  });
}

Tip: MDN’s snippet shows the same flow. This tutorial calls document.hasRedemptionRecord(...) because the method is an instance method on Document.

⚖️ hasRedemptionRecord vs hasPrivateToken

Examples Gallery

Examples follow MDN Document: hasRedemptionRecord() with beginner-safe feature detection. Many demos will report “not supported” outside Chromium.

if (typeof document.hasRedemptionRecord === "function") {
  console.log("hasRedemptionRecord is available");
} else {
  console.log("hasRedemptionRecord is not supported in this browser");
}

hasRedemptionRecord is available
— or —
hasRedemptionRecord is not supported in this browser

async function checkIssuer(issuer) {
  if (typeof document.hasRedemptionRecord !== "function") {
    return "unsupported";
  }
  const hasRR = await document.hasRedemptionRecord(issuer);
  return hasRR ? "redemption record present" : "no redemption record yet";
}

checkIssuer("https://issuer.example").then(console.log);

unsupported
— or —
no redemption record yet
— or —
redemption record present

async function sendIfPresent(issuer, resourceUrl) {
  if (typeof document.hasRedemptionRecord !== "function") {
    throw new Error("Private State Tokens not supported");
  }

  const hasRR = await document.hasRedemptionRecord(issuer);
  if (hasRR) {
    await fetch(resourceUrl, {
      method: "POST",
      privateToken: {
        version: 1,
        operation: "send-redemption-record",
        issuers: [issuer],
      },
    });
  }
  return hasRR;
}

Would check, then maybe POST send-redemption-record
(requires a real issuer + supporting browser)

async function safeHasRR(issuer) {
  if (typeof document.hasRedemptionRecord !== "function") {
    return { ok: false, reason: "unsupported" };
  }
  try {
    const hasRR = await document.hasRedemptionRecord(issuer);
    return { ok: true, hasRR };
  } catch (err) {
    // TypeError | NotAllowedError | InvalidStateError (MDN)
    return { ok: false, reason: err.name, message: err.message };
  }
}

safeHasRR("not-a-url").then(console.log);

{ ok: false, reason: "unsupported" }
— or —
{ ok: false, reason: "TypeError", message: "..." }

async function snapshot(issuer) {
  const out = {
    hasPrivateToken: "unsupported",
    hasRedemptionRecord: "unsupported",
  };

  if (typeof document.hasPrivateToken === "function") {
    out.hasPrivateToken = await document.hasPrivateToken(issuer);
  }
  if (typeof document.hasRedemptionRecord === "function") {
    out.hasRedemptionRecord = await document.hasRedemptionRecord(issuer);
  }
  return out;
}

snapshot("https://issuer.example").then(console.log);

{
  "hasPrivateToken": "unsupported",
  "hasRedemptionRecord": "unsupported"
}

🚀 Common Use Cases

• Send only when ready — MDN: call send-redemption-record after confirming a record exists.
• Privacy-preserving trust — Private State Tokens as a cookie-alternative family (MDN API).
• Feature-gated UX — hide redemption flows when the method is unsupported.
• Secure-only demos — enforce HTTPS before calling the API.
• Paired checks — combine with hasPrivateToken().
• Learning / migration — understand experimental privacy APIs without relying on them yet in production.

📝 Notes

• MDN: marked Experimental — verify compatibility before production.
• MDN: returns a Promise that fulfills with a boolean.
• MDN: issuer must be a valid URL or you get TypeError.
• MDN: secure context required; otherwise NotAllowedError.
• Not the same as hasPrivateToken() — different stored artifact.
• Related: hasPrivateToken(), hasStorageAccess(), hasFocus().

💡 Best Practices