diff --git a/src/actions/promocode-actions.js b/src/actions/promocode-actions.js
index 863d0cc3e..efd0f23a0 100644
--- a/src/actions/promocode-actions.js
+++ b/src/actions/promocode-actions.js
@@ -240,7 +240,7 @@ export const getPromocode = (promocodeId) => async (dispatch, getState) => {
 
   const params = {
     expand:
-      "owner,sponsor,sponsor.company,sponsor.sponsorship,sponsor.sponsorship.type,ticket_type,ticket_types_rules,tags,allowed_ticket_types",
+      "owner,sponsor,sponsor.company,sponsor.sponsorship,sponsor.sponsorship.type,ticket_type,ticket_types_rules,tags,allowed_ticket_types,allowed_email_domains",
     relations:
       "owner,sponsor,ticket_types_rules,tags,allowed_ticket_types,badge_features",
     access_token: accessToken
diff --git a/src/components/forms/promocode-form/__tests__/promocode-form.integration.test.js b/src/components/forms/promocode-form/__tests__/promocode-form.integration.test.js
new file mode 100644
index 000000000..6e88578eb
--- /dev/null
+++ b/src/components/forms/promocode-form/__tests__/promocode-form.integration.test.js
@@ -0,0 +1,602 @@
+import React from "react";
+import { render, fireEvent, screen } from "@testing-library/react";
+
+import PromocodeForm from "../index";
+
+// jsdom does not implement scrollIntoView; polyfill so componentDidUpdate
+// (which calls scrollToError → firstNode.scrollIntoView) does not throw.
+window.HTMLElement.prototype.scrollIntoView = jest.fn();
+
+// openstack-uicore-foundation components used across the PromocodeForm tree.
+// Master commit cd8b5b98 ("Reduce bundle size") rewrote barrel imports to
+// direct paths to avoid pulling the entire components index. Each component
+// the SUT renders is mocked at its direct path below. Each factory inlines the
+// passthrough body because babel-plugin-jest-hoist hoists `jest.mock` calls
+// above any `const` declarations — references outside the factory ReferenceError.
+/* eslint-disable global-require */
+jest.mock("openstack-uicore-foundation/lib/components/inputs/dropdown", () => {
+  const React = require("react");
+  return {
+    __esModule: true,
+    default: (props) =>
+      React.createElement("input", {
+        id: props.id ?? "Dropdown",
+        "data-mocked": "Dropdown",
+        type: props.type ?? "text",
+        value: props.value ?? "",
+        onChange: props.onChange ?? (() => {})
+      })
+  };
+});
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/text-input",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "Input",
+          "data-mocked": "Input",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/textarea-input",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "TextArea",
+          "data-mocked": "TextArea",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/datetimepicker",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "DateTimePicker",
+          "data-mocked": "DateTimePicker",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/ticket-types-input",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "TicketTypesInput",
+          "data-mocked": "TicketTypesInput",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/speaker-input",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "SpeakerInput",
+          "data-mocked": "SpeakerInput",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock(
+  "openstack-uicore-foundation/lib/components/inputs/sponsor-input",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props) =>
+        React.createElement("input", {
+          id: props.id ?? "SponsorInput",
+          "data-mocked": "SponsorInput",
+          type: props.type ?? "text",
+          value: props.value ?? "",
+          onChange: props.onChange ?? (() => {})
+        })
+    };
+  }
+);
+jest.mock("openstack-uicore-foundation/lib/components/free-text-search", () => {
+  const React = require("react");
+  return {
+    __esModule: true,
+    default: (props) =>
+      React.createElement("input", {
+        id: props.id ?? "FreeTextSearch",
+        "data-mocked": "FreeTextSearch",
+        type: props.type ?? "text",
+        value: props.value ?? "",
+        onChange: props.onChange ?? (() => {})
+      })
+  };
+});
+jest.mock("openstack-uicore-foundation/lib/components/table", () => ({
+  __esModule: true,
+  default: () => null
+}));
+/* eslint-enable global-require */
+
+jest.mock("openstack-uicore-foundation/lib/components/inputs/tag-input", () => {
+  // eslint-disable-next-line global-require
+  const React = require("react");
+  const TagInputMock = (props) => {
+    const draftRef = React.useRef("");
+    return React.createElement(
+      "div",
+      {
+        id: props.id,
+        "data-mocked": "TagInput",
+        "data-field": props.id
+      },
+      React.createElement("input", {
+        "data-testid": `taginput-draft-${props.id}`,
+        onChange: (e) => {
+          draftRef.current = e.target.value;
+        }
+      }),
+      React.createElement(
+        "button",
+        {
+          type: "button",
+          "data-testid": `taginput-onCreate-${props.id}`,
+          onClick: () => props.onCreate && props.onCreate(draftRef.current)
+        },
+        "add"
+      )
+    );
+  };
+  return { __esModule: true, default: TagInputMock };
+});
+
+jest.mock("openstack-uicore-foundation/lib/utils/methods", () => ({
+  epochToMomentTimeZone: () => null
+}));
+
+// Other deep imports inside the PromocodeForm tree — stubbed so the component
+// tree mounts in jsdom without pulling in chart libs, rich text editors, etc.
+// Paths below are relative to THIS test file at
+// src/components/forms/promocode-form/__tests__/promocode-form.integration.test.js
+// and must resolve to the same files the SUT imports. Verify with:
+//   node -e "require.resolve('<path>')" from the test file's directory if in doubt.
+jest.mock("../../../inputs/owner-input", () => () => null);
+jest.mock("../../../inputs/text-area-input-with-counter", () => (props) => {
+  const React = require("react");
+  return React.createElement("textarea", {
+    id: props.id,
+    value: props.value ?? "",
+    onChange: props.onChange ?? (() => {})
+  });
+});
+jest.mock("../../../tables/dicount-ticket-table", () => ({
+  DiscountTicketTable: () => null
+}));
+jest.mock(
+  "../../../../utils/fragmen-parser",
+  () =>
+    class FragmentParser {
+      getParam() {
+        return null;
+      }
+    }
+);
+
+const baseEntity = (overrides = {}) => ({
+  id: 0,
+  class_name: null,
+  type: "",
+  code: "",
+  tags: [],
+  description: "",
+  allows_to_delegate: false,
+  allows_to_reassign: true,
+  allowed_ticket_types: [],
+  allowed_email_domains: [],
+  quantity_per_account: 0,
+  auto_apply: false,
+  quantity_available: 0,
+  quantity_used: 0,
+  valid_since_date: "",
+  valid_until_date: "",
+  badge_features: [],
+  ticket_types_rules: [],
+  apply_to_all_tix: true,
+  badge_features_apply_to_all_tix_retroactively: false,
+  amount: "",
+  rate: "",
+  owner: null,
+  speaker: null,
+  sponsor: null,
+  // speakers fragment (speakers-base-pc-form.js) destructures entity.speakers;
+  // provide an empty structure so SPEAKERS_* class renders without crashing.
+  speakers: {
+    filtered_speakers_list: [],
+    speakers_list: [],
+    term: "",
+    order: "id",
+    orderDir: 1,
+    currentPage: 1,
+    lastPage: 1
+  },
+  ...overrides
+});
+
+const baseSummit = {
+  id: 1,
+  badge_features: [],
+  ticket_types: [],
+  time_zone_id: "UTC",
+  default_ticket_type_currency_symbol: "$"
+};
+
+const renderForm = (entity, extraProps = {}) =>
+  render(
+    <PromocodeForm
+      entity={entity}
+      errors={{}}
+      currentSummit={baseSummit}
+      allClasses={[
+        { class_name: "MEMBER_PROMO_CODE", type: [] },
+        { class_name: "MEMBER_DISCOUNT_CODE", type: [] },
+        { class_name: "SPEAKER_PROMO_CODE", type: [] },
+        { class_name: "SPEAKER_DISCOUNT_CODE", type: [] },
+        { class_name: "SPONSOR_PROMO_CODE", type: [] },
+        { class_name: "SPONSOR_DISCOUNT_CODE", type: [] },
+        { class_name: "SUMMIT_PROMO_CODE", type: [] },
+        { class_name: "SUMMIT_DISCOUNT_CODE", type: [] },
+        { class_name: "PRE_PAID_PROMO_CODE", type: [] },
+        { class_name: "PRE_PAID_DISCOUNT_CODE", type: [] },
+        { class_name: "SPEAKERS_PROMO_CODE", type: [] },
+        { class_name: "SPEAKERS_DISCOUNT_CODE", type: [] },
+        { class_name: "DOMAIN_AUTHORIZED_PROMO_CODE", type: [] },
+        { class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE", type: [] }
+      ]}
+      onSubmit={() => {}}
+      onSendEmail={() => {}}
+      onBadgeFeatureLink={() => {}}
+      onBadgeFeatureUnLink={() => {}}
+      onCreateCompany={() => {}}
+      assignSpeaker={() => {}}
+      getAssignedSpeakers={() => {}}
+      unAssignSpeaker={() => {}}
+      resetPromocodeForm={() => {}}
+      {...extraProps}
+    />
+  );
+
+describe("PromocodeForm class switching", () => {
+  it("renders domain-authorized access-only fields when class is DOMAIN_AUTHORIZED_PROMO_CODE", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "DOMAIN_AUTHORIZED_PROMO_CODE" })
+    );
+    expect(
+      container.querySelector("#allowed_email_domains")
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector("#quantity_per_account")
+    ).toBeInTheDocument();
+    expect(container.querySelector("#auto_apply")).toBeInTheDocument();
+    expect(
+      container.querySelector("#allowed_ticket_types")
+    ).toBeInTheDocument();
+    // Discount-only fields must NOT render on the access-only variant.
+    expect(container.querySelector("#amount")).not.toBeInTheDocument();
+    expect(container.querySelector("#rate")).not.toBeInTheDocument();
+  });
+
+  it("renders domain-authorized discount fields when class is DOMAIN_AUTHORIZED_DISCOUNT_CODE", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE" })
+    );
+    expect(
+      container.querySelector("#allowed_email_domains")
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector("#quantity_per_account")
+    ).toBeInTheDocument();
+    expect(container.querySelector("#auto_apply")).toBeInTheDocument();
+    expect(container.querySelector("#amount")).toBeInTheDocument();
+    expect(container.querySelector("#rate")).toBeInTheDocument();
+  });
+
+  it.each([
+    "MEMBER_PROMO_CODE",
+    "MEMBER_DISCOUNT_CODE",
+    "SPEAKER_PROMO_CODE",
+    "SPEAKER_DISCOUNT_CODE"
+  ])("shows auto_apply checkbox when class is %s", (class_name) => {
+    const { container } = renderForm(baseEntity({ class_name }));
+    expect(container.querySelector("#auto_apply")).toBeInTheDocument();
+  });
+
+  it("does NOT show auto_apply checkbox when class is SPONSOR_PROMO_CODE", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "SPONSOR_PROMO_CODE" })
+    );
+    expect(container.querySelector("#auto_apply")).not.toBeInTheDocument();
+  });
+
+  describe("allowed_email_domains commit path", () => {
+    const addDomain = (container, value) => {
+      // Post-PR-#915-review: AllowedEmailDomainsRow uses a bare freeform
+      // input (no TagInput / react-select) — see santipalenque's review.
+      const input = container.querySelector(
+        "[data-testid=\"allowed_email_domains_input\"]"
+      );
+      fireEvent.change(input, { target: { value } });
+      fireEvent.keyDown(input, { key: "Enter" });
+    };
+
+    it("rejects malformed entries inline and leaves handleChange (for domains) uncalled", () => {
+      const { container } = renderForm(
+        baseEntity({ class_name: "DOMAIN_AUTHORIZED_PROMO_CODE" })
+      );
+      addDomain(container, "acme.com"); // no leading @ — invalid
+      // i18n-react renders the raw key in the jest env (no translator is
+      // configured here), so we match the key itself rather than the
+      // translated copy. The rendered string is:
+      //   "edit_promocode.errors.allowed_email_domains_format"
+      expect(
+        container.querySelector(".text-danger")?.textContent ?? ""
+      ).toMatch(/allowed_email_domains_format/i);
+    });
+
+    it("accepts a valid @domain entry", () => {
+      const { container } = renderForm(
+        baseEntity({ class_name: "DOMAIN_AUTHORIZED_PROMO_CODE" })
+      );
+      addDomain(container, "@acme.com");
+      // No inline error after a valid add.
+      expect(container.querySelector(".text-danger")).toBeNull();
+    });
+
+    it("accepts a valid .tld entry (case-insensitive)", () => {
+      const { container } = renderForm(
+        baseEntity({ class_name: "DOMAIN_AUTHORIZED_PROMO_CODE" })
+      );
+      addDomain(container, ".EDU");
+      expect(container.querySelector(".text-danger")).toBeNull();
+    });
+  });
+});
+
+describe("DOMAIN_AUTHORIZED layout positions", () => {
+  it("renders auto_apply as the third checkbox in the description-row column", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE" })
+    );
+    const checkboxesDiv = container.querySelector(".checkboxes-div");
+    const checkboxes = checkboxesDiv.querySelectorAll("input[type=\"checkbox\"]");
+    expect(checkboxes).toHaveLength(3);
+    expect(checkboxes[0].id).toBe("allows_to_delegate");
+    expect(checkboxes[1].id).toBe("allows_to_reassign");
+    expect(checkboxes[2].id).toBe("auto_apply");
+  });
+
+  it("renders quantity_per_account as the third col-md-4 in the quantity row", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE" })
+    );
+    const quantityRow = container
+      .querySelector("#quantity_available")
+      .closest(".row.form-group");
+    const cols = quantityRow.querySelectorAll(".col-md-4");
+    expect(cols).toHaveLength(3);
+    expect(cols[0].querySelector("#quantity_available")).toBeTruthy();
+    expect(cols[1].querySelector("#quantity_used")).toBeTruthy();
+    expect(cols[2].querySelector("#quantity_per_account")).toBeTruthy();
+  });
+
+  it("renders allowed-email-domains-row before the description row", () => {
+    const { container } = renderForm(
+      baseEntity({ class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE" })
+    );
+    const emailDomainsRow = container.querySelector(
+      "[data-testid=\"allowed-email-domains-row\"]"
+    );
+    const descriptionRow = container
+      .querySelector("#description")
+      .closest(".row.form-group");
+    expect(emailDomainsRow).toBeTruthy();
+    expect(descriptionRow).toBeTruthy();
+    /* eslint-disable no-bitwise */
+    // bitmask 4 = DOCUMENT_POSITION_FOLLOWING
+    const followsBit =
+      emailDomainsRow.compareDocumentPosition(descriptionRow) & 4;
+    /* eslint-enable no-bitwise */
+    expect(followsBit).toBeTruthy();
+  });
+});
+
+describe("validate() — domain-authorized email-domain enforcement", () => {
+  it("blocks save on malformed allowed_email_domains for DOMAIN_AUTHORIZED_DISCOUNT_CODE", () => {
+    const onSubmit = jest.fn();
+    const { container } = renderForm(
+      baseEntity({
+        class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+        allowed_email_domains: ["malformed-no-at-sign"]
+      }),
+      { onSubmit }
+    );
+    // T.translate("general.save") renders the raw key "general.save" in the
+    // jest env (no locale loaded; same behavior the existing file documents
+    // starting at :227). The regex /save/i matches the substring within the
+    // raw key, so the button is found.
+    fireEvent.click(screen.getByRole("button", { name: /save/i }));
+    expect(onSubmit).not.toHaveBeenCalled();
+    // Validate-path error must reach the DOM via the hasErrors prop wired
+    // through to AllowedEmailDomainsRow — otherwise Save silently no-ops
+    // (the bug smarcet flagged on PR #915).
+    expect(container.querySelector(".text-danger")?.textContent ?? "").toMatch(
+      /allowed_email_domains_format/i
+    );
+  });
+
+  it("scrolls to the offending field even when other fields were edited first", () => {
+    // Regression for a bug introduced when scrollToError(state.errors) was
+    // first added to validate(): handleChange (index.js:114) writes
+    // newErrors[id] = "" on every edit, so state.errors accumulates
+    // empty-string keys. scrollToError uses Object.keys()[0] without
+    // filtering empties, so it would scroll to the first-edited field
+    // rather than the one with the actual error. Pass a single-key object.
+    const getByIdSpy = jest.spyOn(document, "getElementById");
+    const { container } = renderForm(
+      baseEntity({
+        class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+        allowed_email_domains: ["malformed"]
+      })
+    );
+    // Edit the `code` field first — this seeds state.errors.code = "".
+    const codeInput = container.querySelector("#code");
+    fireEvent.change(codeInput, { target: { value: "EARLY-BIRD" } });
+    getByIdSpy.mockClear();
+    fireEvent.click(screen.getByRole("button", { name: /save/i }));
+    expect(getByIdSpy).toHaveBeenCalledWith("allowed_email_domains");
+    expect(getByIdSpy).not.toHaveBeenCalledWith("code");
+    getByIdSpy.mockRestore();
+  });
+
+  it("clears the .text-danger banner on plain typing after a failed save (regression — Codex review)", () => {
+    const { container } = renderForm(
+      baseEntity({
+        class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+        allowed_email_domains: ["malformed"]
+      })
+    );
+    fireEvent.click(screen.getByRole("button", { name: /save/i }));
+    expect(container.querySelector(".text-danger")?.textContent ?? "").toMatch(
+      /allowed_email_domains_format/i
+    );
+    // Typing into the input alone (no commit, no chip-remove) should clear
+    // the parent error banner — the chip input must mirror handleChange:114
+    // semantics that every other field on the form gets via direct
+    // onChange wiring.
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    fireEvent.change(input, { target: { value: "@" } });
+    expect(container.querySelector(".text-danger")).toBeNull();
+  });
+
+  it("allows save on valid allowed_email_domains for DOMAIN_AUTHORIZED_DISCOUNT_CODE", () => {
+    const onSubmit = jest.fn();
+    renderForm(
+      baseEntity({
+        class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+        allowed_email_domains: ["@valid.com", ".edu"]
+      }),
+      { onSubmit }
+    );
+    fireEvent.click(screen.getByRole("button", { name: /save/i }));
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT validate allowed_email_domains for non-DomainAuthorized classes (MEMBER_PROMO_CODE)", () => {
+    const onSubmit = jest.fn();
+    renderForm(
+      baseEntity({
+        class_name: "MEMBER_PROMO_CODE",
+        allowed_email_domains: ["malformed"] // present but should be ignored
+      }),
+      { onSubmit }
+    );
+    fireEvent.click(screen.getByRole("button", { name: /save/i }));
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("regression — non-DomainAuthorized classes are unaffected by the layout reflow", () => {
+  // Block 1: classes whose own fragments render #auto_apply
+  // (MEMBER, SPEAKER variants). See member-base-pc-form.js:27 and
+  // speaker-base-pc-form.js:25 — both render <input id="auto_apply">
+  // unconditionally.
+  it.each([
+    ["MEMBER_PROMO_CODE"],
+    ["MEMBER_DISCOUNT_CODE"],
+    ["SPEAKER_PROMO_CODE"],
+    ["SPEAKER_DISCOUNT_CODE"]
+  ])(
+    "for %s: does NOT render the new DomainAuthorized layout but DOES render fragment-owned #auto_apply",
+    (class_name) => {
+      const { container } = renderForm(baseEntity({ class_name }));
+      const quantityRow = container
+        .querySelector("#quantity_available")
+        .closest(".row.form-group");
+      const cols = quantityRow.querySelectorAll(".col-md-4");
+      expect(cols).toHaveLength(2);
+      expect(
+        container.querySelector("#quantity_per_account")
+      ).not.toBeInTheDocument();
+      expect(
+        container.querySelector("[data-testid=\"allowed-email-domains-row\"]")
+      ).not.toBeInTheDocument();
+      // member/speaker fragments still render auto_apply (unchanged)
+      expect(container.querySelector("#auto_apply")).toBeInTheDocument();
+    }
+  );
+
+  // Block 2: classes that should have NO #auto_apply anywhere.
+  // SUMMIT_*, PRE_PAID_*, SPEAKERS_*, SPONSOR_* — none of their fragments
+  // render auto_apply. PRE_PAID_* routes through SummitPCForm /
+  // SummitDiscountPCForm per index.js:494-518.
+  it.each([
+    ["SPONSOR_PROMO_CODE"],
+    ["SPONSOR_DISCOUNT_CODE"],
+    ["SUMMIT_PROMO_CODE"],
+    ["SUMMIT_DISCOUNT_CODE"],
+    ["PRE_PAID_PROMO_CODE"],
+    ["PRE_PAID_DISCOUNT_CODE"],
+    ["SPEAKERS_PROMO_CODE"],
+    ["SPEAKERS_DISCOUNT_CODE"]
+  ])(
+    "for %s: does NOT render the new DomainAuthorized layout and does NOT render #auto_apply",
+    (class_name) => {
+      const { container } = renderForm(baseEntity({ class_name }));
+      const quantityRow = container
+        .querySelector("#quantity_available")
+        .closest(".row.form-group");
+      const cols = quantityRow.querySelectorAll(".col-md-4");
+      expect(cols).toHaveLength(2);
+      expect(
+        container.querySelector("#quantity_per_account")
+      ).not.toBeInTheDocument();
+      expect(container.querySelector("#auto_apply")).not.toBeInTheDocument();
+      expect(
+        container.querySelector("[data-testid=\"allowed-email-domains-row\"]")
+      ).not.toBeInTheDocument();
+    }
+  );
+});
diff --git a/src/components/forms/promocode-form/forms/__tests__/auto-apply-checkbox.test.jsx b/src/components/forms/promocode-form/forms/__tests__/auto-apply-checkbox.test.jsx
new file mode 100644
index 000000000..01726d693
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/__tests__/auto-apply-checkbox.test.jsx
@@ -0,0 +1,77 @@
+import React from "react";
+import { render, fireEvent, screen } from "@testing-library/react";
+import AutoApplyCheckbox from "../auto-apply-checkbox";
+
+const baseEntity = (overrides = {}) => ({
+  auto_apply: false,
+  ...overrides
+});
+
+describe("AutoApplyCheckbox", () => {
+  it("renders unchecked when entity.auto_apply is false", () => {
+    const { container } = render(
+      <AutoApplyCheckbox entity={baseEntity()} handleChange={() => {}} />
+    );
+    const cb = container.querySelector("#auto_apply");
+    expect(cb).toBeInTheDocument();
+    expect(cb.checked).toBe(false);
+  });
+
+  it("renders checked when entity.auto_apply is true", () => {
+    const { container } = render(
+      <AutoApplyCheckbox
+        entity={baseEntity({ auto_apply: true })}
+        handleChange={() => {}}
+      />
+    );
+    expect(container.querySelector("#auto_apply").checked).toBe(true);
+  });
+
+  it("calls handleChange with checkbox event shape on toggle", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AutoApplyCheckbox entity={baseEntity()} handleChange={handleChange} />
+    );
+    fireEvent.click(container.querySelector("#auto_apply"));
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange).toHaveBeenCalledWith({
+      target: {
+        id: "auto_apply",
+        type: "checkbox",
+        value: true,
+        checked: true
+      }
+    });
+  });
+
+  it("does not render the caption by default (member/speaker fragment shape)", () => {
+    render(<AutoApplyCheckbox entity={baseEntity()} handleChange={() => {}} />);
+    expect(
+      screen.queryByText("edit_promocode.captions.auto_apply")
+    ).not.toBeInTheDocument();
+  });
+
+  it("renders the caption when withCaption is set (DomainAuthorized leaf shape)", () => {
+    render(
+      <AutoApplyCheckbox
+        entity={baseEntity()}
+        handleChange={() => {}}
+        withCaption
+      />
+    );
+    expect(
+      screen.getByText("edit_promocode.captions.auto_apply")
+    ).toBeInTheDocument();
+  });
+
+  it("applies marginTop:10px when marginTop is set", () => {
+    const { container } = render(
+      <AutoApplyCheckbox
+        entity={baseEntity()}
+        handleChange={() => {}}
+        marginTop
+      />
+    );
+    expect(container.firstChild).toHaveStyle({ marginTop: "10px" });
+  });
+});
diff --git a/src/components/forms/promocode-form/forms/auto-apply-checkbox.jsx b/src/components/forms/promocode-form/forms/auto-apply-checkbox.jsx
new file mode 100644
index 000000000..42104de2a
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/auto-apply-checkbox.jsx
@@ -0,0 +1,46 @@
+import React from "react";
+import T from "i18n-react";
+import { fireChange } from "./domain-authorized/utils";
+
+// Shared `auto_apply` checkbox. Used by:
+//  - DomainAuthorized leaf (orchestrator's .checkboxes-div) with
+//    {withCaption, marginTop} — host provides no row context.
+//  - Member/Speaker fragments — host wraps in its own .row.form-group.
+const AutoApplyCheckbox = ({
+  entity,
+  handleChange,
+  withCaption = false,
+  marginTop = false
+}) => (
+  <div
+    className="form-check abc-checkbox"
+    style={marginTop ? { marginTop: "10px" } : undefined}
+  >
+    <input
+      type="checkbox"
+      id="auto_apply"
+      checked={!!entity.auto_apply}
+      onChange={(ev) =>
+        fireChange(handleChange, "auto_apply", ev.target.checked, "checkbox", {
+          checked: ev.target.checked
+        })
+      }
+      className="form-check-input"
+    />
+    <label className="form-check-label" htmlFor="auto_apply">
+      {T.translate("edit_promocode.auto_apply")}&nbsp;
+      <i
+        className="fa fa-info-circle"
+        aria-hidden="true"
+        title={T.translate("edit_promocode.info.auto_apply")}
+      />
+    </label>
+    {withCaption && (
+      <small className="form-text text-muted" style={{ display: "block" }}>
+        {T.translate("edit_promocode.captions.auto_apply")}
+      </small>
+    )}
+  </div>
+);
+
+export default AutoApplyCheckbox;
diff --git a/src/components/forms/promocode-form/forms/base-pc-form.js b/src/components/forms/promocode-form/forms/base-pc-form.js
index d32c75f40..033a23724 100644
--- a/src/components/forms/promocode-form/forms/base-pc-form.js
+++ b/src/components/forms/promocode-form/forms/base-pc-form.js
@@ -5,6 +5,8 @@ import Dropdown from "openstack-uicore-foundation/lib/components/inputs/dropdown
 import Input from "openstack-uicore-foundation/lib/components/inputs/text-input"
 import TextArea from "openstack-uicore-foundation/lib/components/inputs/textarea-input";
 import { epochToMomentTimeZone } from "openstack-uicore-foundation/lib/utils/methods";
+import { isDomainAuthorizedClass } from "./domain-authorized/utils";
+import MaxPerAccountInput from "./domain-authorized/MaxPerAccountInput";
 
 const BasePCForm = (props) => {
   const badge_features_ddl = props.summit.badge_features.map((f) => ({
@@ -17,6 +19,7 @@ const BasePCForm = (props) => {
     "PRE_PAID_PROMO_CODE",
     "PRE_PAID_DISCOUNT_CODE"
   ].includes(props.entity.class_name);
+  const isDomainAuthorized = isDomainAuthorizedClass(props.entity.class_name);
 
   return (
     <>
@@ -51,6 +54,12 @@ const BasePCForm = (props) => {
             disabled
           />
         </div>
+        {isDomainAuthorized && (
+          <MaxPerAccountInput
+            entity={props.entity}
+            handleChange={props.handleChange}
+          />
+        )}
       </div>
       <div className="row form-group">
         <div className="col-md-4">
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/AllowedEmailDomainsRow.jsx b/src/components/forms/promocode-form/forms/domain-authorized/AllowedEmailDomainsRow.jsx
new file mode 100644
index 000000000..1a92557d6
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/AllowedEmailDomainsRow.jsx
@@ -0,0 +1,176 @@
+import React, { useState } from "react";
+import T from "i18n-react";
+import { validateAllowedEmailDomainEntry } from "../../../../../utils/methods";
+import { fireChange } from "./utils";
+
+// Freeform chip input. Deliberately NOT openstack-uicore-foundation's
+// TagInput: that component wraps react-select's AsyncCreatable and fires
+// `queryTags` against `/api/v1/.../allowed-tags` on every keystroke. Email
+// domains have nothing to do with the Tags table — see PR #915 review.
+const AllowedEmailDomainsRow = ({
+  entity,
+  handleChange,
+  hasErrors = () => ""
+}) => {
+  const [draft, setDraft] = useState("");
+  const [domainsError, setDomainsError] = useState("");
+
+  const domains = Array.isArray(entity.allowed_email_domains)
+    ? entity.allowed_email_domains
+    : [];
+
+  // validate-path error (parent state) takes precedence over the local
+  // commit-path error so a failed Save with a malformed pre-existing chip
+  // surfaces in the DOM. handleChange clears parent state.errors[id] on the
+  // next user edit, so this naturally clears too.
+  const renderedError = hasErrors("allowed_email_domains") || domainsError;
+
+  const commit = (raw) => {
+    const trimmed = (raw ?? "").trim();
+    if (trimmed.length === 0) return;
+    if (!validateAllowedEmailDomainEntry(trimmed)) {
+      setDomainsError(
+        T.translate("edit_promocode.errors.allowed_email_domains_format")
+      );
+      return;
+    }
+    if (!domains.includes(trimmed)) {
+      fireChange(handleChange, "allowed_email_domains", [...domains, trimmed]);
+    }
+    setDraft("");
+    setDomainsError("");
+  };
+
+  const removeAt = (idx) => {
+    const next = domains.filter((_, i) => i !== idx);
+    fireChange(handleChange, "allowed_email_domains", next);
+    setDomainsError("");
+  };
+
+  const handleKeyDown = (ev) => {
+    if (ev.key === "Enter" || ev.key === ",") {
+      ev.preventDefault();
+      commit(draft);
+      return;
+    }
+    if (ev.key === "Backspace" && draft.length === 0 && domains.length > 0) {
+      ev.preventDefault();
+      removeAt(domains.length - 1);
+    }
+  };
+
+  const handleBlur = () => {
+    if (draft.length > 0) commit(draft);
+  };
+
+  return (
+    <div className="row form-group" data-testid="allowed-email-domains-row">
+      <div className="col-md-12">
+        <label htmlFor="allowed_email_domains">
+          {T.translate("edit_promocode.allowed_email_domains")}&nbsp;
+          <i
+            className="fa fa-info-circle"
+            aria-hidden="true"
+            title={T.translate("edit_promocode.info.allowed_email_domains")}
+          />
+        </label>
+        <div
+          id="allowed_email_domains"
+          className="form-control"
+          style={{
+            minHeight: 38,
+            height: "auto",
+            display: "flex",
+            flexWrap: "wrap",
+            gap: 4,
+            alignItems: "center"
+          }}
+        >
+          {domains.map((d, idx) => (
+            <span
+              key={d}
+              className="label label-default"
+              data-testid={`domain-chip-${d}`}
+              style={{
+                padding: "4px 8px",
+                display: "inline-flex",
+                alignItems: "center",
+                gap: 4,
+                fontSize: "0.95em"
+              }}
+            >
+              {d}
+              <button
+                type="button"
+                aria-label={`remove ${d}`}
+                data-testid={`domain-chip-remove-${d}`}
+                onClick={() => removeAt(idx)}
+                style={{
+                  background: "transparent",
+                  border: 0,
+                  padding: 0,
+                  marginLeft: 4,
+                  color: "inherit",
+                  fontWeight: "bold",
+                  cursor: "pointer",
+                  lineHeight: 1
+                }}
+              >
+                &times;
+              </button>
+            </span>
+          ))}
+          <input
+            type="text"
+            data-testid="allowed_email_domains_input"
+            aria-label={T.translate("edit_promocode.allowed_email_domains")}
+            value={draft}
+            placeholder={
+              domains.length === 0
+                ? T.translate(
+                    "edit_promocode.placeholders.allowed_email_domains"
+                  )
+                : ""
+            }
+            onChange={(e) => {
+              setDraft(e.target.value);
+              setDomainsError("");
+              // Parallel-clear the parent validate()-path error so the
+              // .text-danger banner disappears as soon as the user starts
+              // editing — same UX every other field gets via index.js:114
+              // (newErrors[id] = "" inside handleChange). The chip input's
+              // onChange normally doesn't bubble to the parent (typing
+              // updates local draft only), so we synthesize a no-op array
+              // change to trigger the parent reset. Only fires when a
+              // parent error is currently set, so the cost (one extra
+              // setState) is paid only after a failed Save.
+              if (hasErrors("allowed_email_domains")) {
+                fireChange(handleChange, "allowed_email_domains", domains);
+              }
+            }}
+            onKeyDown={handleKeyDown}
+            onBlur={handleBlur}
+            style={{
+              border: 0,
+              outline: "none",
+              flex: 1,
+              minWidth: 120,
+              background: "transparent",
+              padding: 0
+            }}
+          />
+        </div>
+        <small className="form-text text-muted">
+          {T.translate("edit_promocode.captions.allowed_email_domains")}
+        </small>
+        {renderedError && (
+          <div className="text-danger" style={{ marginTop: 4 }}>
+            {renderedError}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default AllowedEmailDomainsRow;
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/MaxPerAccountInput.jsx b/src/components/forms/promocode-form/forms/domain-authorized/MaxPerAccountInput.jsx
new file mode 100644
index 000000000..653475a5c
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/MaxPerAccountInput.jsx
@@ -0,0 +1,39 @@
+import React from "react";
+import T from "i18n-react";
+import Input from "openstack-uicore-foundation/lib/components/inputs/text-input";
+import { fireChange } from "./utils";
+
+// Returns the col-md-4 directly. Host (BasePCForm's Quantity row) provides
+// the .row.form-group wrapper.
+const MaxPerAccountInput = ({ entity, handleChange }) => (
+  <div className="col-md-4">
+    <label htmlFor="quantity_per_account">
+      {T.translate("edit_promocode.quantity_per_account")}&nbsp;
+      <i
+        className="fa fa-info-circle"
+        aria-hidden="true"
+        title={T.translate("edit_promocode.info.quantity_per_account")}
+      />
+    </label>
+    <Input
+      id="quantity_per_account"
+      type="number"
+      min="0"
+      value={entity.quantity_per_account}
+      onChange={(ev) =>
+        fireChange(
+          handleChange,
+          "quantity_per_account",
+          ev.target.value,
+          "number"
+        )
+      }
+      className="form-control"
+    />
+    <small className="form-text text-muted">
+      {T.translate("edit_promocode.captions.quantity_per_account_unlimited")}
+    </small>
+  </div>
+);
+
+export default MaxPerAccountInput;
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/__tests__/allowed-email-domains-row.test.jsx b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/allowed-email-domains-row.test.jsx
new file mode 100644
index 000000000..c0b51fa7c
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/allowed-email-domains-row.test.jsx
@@ -0,0 +1,303 @@
+import React from "react";
+import { render, screen, fireEvent } from "@testing-library/react";
+import AllowedEmailDomainsRow from "../AllowedEmailDomainsRow";
+
+const baseEntity = (overrides = {}) => ({
+  allowed_email_domains: [],
+  ...overrides
+});
+
+const typeAndCommit = (container, value) => {
+  const input = container.querySelector(
+    "[data-testid='allowed_email_domains_input']"
+  );
+  fireEvent.change(input, { target: { value } });
+  fireEvent.keyDown(input, { key: "Enter" });
+};
+
+describe("AllowedEmailDomainsRow", () => {
+  it("renders the input and visible caption", () => {
+    const { container } = render(
+      <AllowedEmailDomainsRow entity={baseEntity()} handleChange={() => {}} />
+    );
+    expect(
+      container.querySelector("#allowed_email_domains")
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector("[data-testid='allowed_email_domains_input']")
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText("edit_promocode.captions.allowed_email_domains")
+    ).toBeInTheDocument();
+  });
+
+  it("renders within a row with data-testid='allowed-email-domains-row'", () => {
+    const { container } = render(
+      <AllowedEmailDomainsRow entity={baseEntity()} handleChange={() => {}} />
+    );
+    expect(
+      container.querySelector("[data-testid=\"allowed-email-domains-row\"]")
+    ).toBeInTheDocument();
+  });
+
+  it("does NOT depend on openstack-uicore-foundation TagInput (no async tag-table fetch)", () => {
+    // Regression for PR #915: confirm the freeform input renders without
+    // the foundation TagInput, which would otherwise hit /allowed-tags.
+    const { container } = render(
+      <AllowedEmailDomainsRow entity={baseEntity()} handleChange={() => {}} />
+    );
+    expect(container.querySelector("[data-mocked='TagInput']")).toBeNull();
+    // The bare <input> is a real DOM input, not a react-select wrapper.
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    expect(input.tagName).toBe("INPUT");
+  });
+
+  it("calls handleChange with the new entry when Enter pressed with a valid @domain", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={handleChange}
+      />
+    );
+    typeAndCommit(container, "@valid.com");
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange).toHaveBeenCalledWith({
+      target: {
+        id: "allowed_email_domains",
+        value: ["@valid.com"],
+        type: "text"
+      }
+    });
+  });
+
+  it("commits on comma keypress as well as Enter", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={handleChange}
+      />
+    );
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    fireEvent.change(input, { target: { value: "@valid.com" } });
+    fireEvent.keyDown(input, { key: "," });
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange.mock.calls[0][0].target.value).toEqual(["@valid.com"]);
+  });
+
+  it("commits on blur when draft is non-empty", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={handleChange}
+      />
+    );
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    fireEvent.change(input, { target: { value: "@valid.com" } });
+    fireEvent.blur(input);
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange.mock.calls[0][0].target.value).toEqual(["@valid.com"]);
+  });
+
+  it("renders an inline error and does NOT call handleChange on a malformed entry", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={handleChange}
+      />
+    );
+    typeAndCommit(container, "invalid");
+    expect(handleChange).not.toHaveBeenCalled();
+    expect(container.querySelector(".text-danger")?.textContent ?? "").toMatch(
+      /allowed_email_domains_format/i
+    );
+  });
+
+  it("removes the chip and fires handleChange when the chip × button is clicked", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity({
+          allowed_email_domains: ["@acme.com", ".edu"]
+        })}
+        handleChange={handleChange}
+      />
+    );
+    const removeBtn = container.querySelector(
+      "[data-testid='domain-chip-remove-@acme.com']"
+    );
+    fireEvent.click(removeBtn);
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange).toHaveBeenCalledWith({
+      target: {
+        id: "allowed_email_domains",
+        value: [".edu"],
+        type: "text"
+      }
+    });
+  });
+
+  it("removes the last chip on Backspace when draft is empty", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity({
+          allowed_email_domains: ["@acme.com", ".edu"]
+        })}
+        handleChange={handleChange}
+      />
+    );
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    fireEvent.keyDown(input, { key: "Backspace" });
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange.mock.calls[0][0].target.value).toEqual(["@acme.com"]);
+  });
+
+  it("does NOT remove a chip on Backspace when draft is non-empty", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity({
+          allowed_email_domains: ["@acme.com"]
+        })}
+        handleChange={handleChange}
+      />
+    );
+    const input = container.querySelector(
+      "[data-testid='allowed_email_domains_input']"
+    );
+    fireEvent.change(input, { target: { value: "@partial" } });
+    fireEvent.keyDown(input, { key: "Backspace" });
+    expect(handleChange).not.toHaveBeenCalled();
+  });
+
+  it("renders chips for each saved entry in entity.allowed_email_domains", () => {
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity({ allowed_email_domains: ["@acme.com", ".edu"] })}
+        handleChange={() => {}}
+      />
+    );
+    expect(
+      container.querySelector("[data-testid=\"domain-chip-@acme.com\"]")
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector("[data-testid=\"domain-chip-.edu\"]")
+    ).toBeInTheDocument();
+  });
+
+  it("renders parent-supplied error from hasErrors prop (validate-path)", () => {
+    const hasErrors = (field) =>
+      field === "allowed_email_domains" ? "boom" : "";
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={() => {}}
+        hasErrors={hasErrors}
+      />
+    );
+    expect(container.querySelector(".text-danger")?.textContent).toBe("boom");
+  });
+
+  it("prefers parent-supplied error over local commit error when both are set", () => {
+    const hasErrors = (field) =>
+      field === "allowed_email_domains" ? "parent-wins" : "";
+    const { container } = render(
+      <AllowedEmailDomainsRow
+        entity={baseEntity()}
+        handleChange={() => {}}
+        hasErrors={hasErrors}
+      />
+    );
+    typeAndCommit(container, "invalid"); // sets local domainsError
+    expect(container.querySelector(".text-danger")?.textContent).toBe(
+      "parent-wins"
+    );
+  });
+
+  it("falls back to local commit error when no hasErrors prop is provided", () => {
+    const { container } = render(
+      <AllowedEmailDomainsRow entity={baseEntity()} handleChange={jest.fn()} />
+    );
+    typeAndCommit(container, "invalid");
+    expect(container.querySelector(".text-danger")?.textContent ?? "").toMatch(
+      /allowed_email_domains_format/i
+    );
+  });
+
+  describe("parent error clears on plain typing (regression — Codex review)", () => {
+    it("fires a no-op fireChange while typing if hasErrors() is truthy, so the parent's state.errors[id] resets via handleChange:114", () => {
+      const handleChange = jest.fn();
+      const hasErrors = jest.fn((field) =>
+        field === "allowed_email_domains" ? "validate-path-error" : ""
+      );
+      const { container } = render(
+        <AllowedEmailDomainsRow
+          entity={baseEntity({
+            allowed_email_domains: ["@existing.com"]
+          })}
+          handleChange={handleChange}
+          hasErrors={hasErrors}
+        />
+      );
+      const input = container.querySelector(
+        "[data-testid='allowed_email_domains_input']"
+      );
+      fireEvent.change(input, { target: { value: "@" } });
+      // Typing fires fireChange with the SAME array — array unchanged,
+      // but the parent's handleChange clears errors[id] (index.js:114).
+      expect(handleChange).toHaveBeenCalledTimes(1);
+      expect(handleChange).toHaveBeenCalledWith({
+        target: {
+          id: "allowed_email_domains",
+          value: ["@existing.com"],
+          type: "text"
+        }
+      });
+    });
+
+    it("does NOT fire fireChange while typing when hasErrors() is falsy (no wasted re-renders on the happy path)", () => {
+      const handleChange = jest.fn();
+      const { container } = render(
+        <AllowedEmailDomainsRow
+          entity={baseEntity({ allowed_email_domains: ["@existing.com"] })}
+          handleChange={handleChange}
+        />
+      );
+      const input = container.querySelector(
+        "[data-testid='allowed_email_domains_input']"
+      );
+      fireEvent.change(input, { target: { value: "@new" } });
+      fireEvent.change(input, { target: { value: "@new." } });
+      fireEvent.change(input, { target: { value: "@new.com" } });
+      expect(handleChange).not.toHaveBeenCalled();
+    });
+  });
+
+  it("clears the local error and the draft after a successful commit", () => {
+    const { container } = render(
+      <AllowedEmailDomainsRow entity={baseEntity()} handleChange={jest.fn()} />
+    );
+    typeAndCommit(container, "invalid");
+    expect(container.querySelector(".text-danger")?.textContent ?? "").toMatch(
+      /allowed_email_domains_format/i
+    );
+    typeAndCommit(container, "@valid.com");
+    expect(container.querySelector(".text-danger")).toBeNull();
+    expect(
+      container.querySelector("[data-testid='allowed_email_domains_input']")
+        .value
+    ).toBe("");
+  });
+});
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/__tests__/max-per-account-input.test.jsx b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/max-per-account-input.test.jsx
new file mode 100644
index 000000000..ba102ae6a
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/max-per-account-input.test.jsx
@@ -0,0 +1,68 @@
+import React from "react";
+import { render, fireEvent, screen } from "@testing-library/react";
+import MaxPerAccountInput from "../MaxPerAccountInput";
+
+// Mocks the direct import path used by MaxPerAccountInput (post-bundle-size
+// rewrite — see master commit cd8b5b98).
+jest.mock("openstack-uicore-foundation/lib/components/inputs/text-input", () => {
+  const React = require("react");
+  const InputMock = (props) =>
+    React.createElement("input", {
+      id: props.id,
+      type: props.type ?? "text",
+      min: props.min,
+      value: props.value ?? "",
+      onChange: props.onChange,
+      className: props.className
+    });
+  return { __esModule: true, default: InputMock };
+});
+
+const baseEntity = (overrides = {}) => ({
+  quantity_per_account: 0,
+  ...overrides
+});
+
+describe("MaxPerAccountInput", () => {
+  it("reflects entity.quantity_per_account on the input value", () => {
+    const { container } = render(
+      <MaxPerAccountInput
+        entity={baseEntity({ quantity_per_account: 7 })}
+        handleChange={() => {}}
+      />
+    );
+    expect(container.querySelector("#quantity_per_account").value).toBe("7");
+  });
+
+  it("calls handleChange with number-event shape on change", () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <MaxPerAccountInput entity={baseEntity()} handleChange={handleChange} />
+    );
+    fireEvent.change(container.querySelector("#quantity_per_account"), {
+      target: { value: "5" }
+    });
+    expect(handleChange).toHaveBeenCalledTimes(1);
+    expect(handleChange).toHaveBeenCalledWith({
+      target: { id: "quantity_per_account", type: "number", value: "5" }
+    });
+  });
+
+  it("renders the visible '0 = unlimited' caption", () => {
+    render(
+      <MaxPerAccountInput entity={baseEntity()} handleChange={() => {}} />
+    );
+    expect(
+      screen.getByText("edit_promocode.captions.quantity_per_account_unlimited")
+    ).toBeInTheDocument();
+  });
+
+  it("renders inside a col-md-4 container", () => {
+    const { container } = render(
+      <MaxPerAccountInput entity={baseEntity()} handleChange={() => {}} />
+    );
+    const col = container.querySelector(".col-md-4");
+    expect(col).toBeInTheDocument();
+    expect(col.querySelector("#quantity_per_account")).toBeInTheDocument();
+  });
+});
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/__tests__/utils.test.js b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/utils.test.js
new file mode 100644
index 000000000..e62cc4eaa
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/__tests__/utils.test.js
@@ -0,0 +1,45 @@
+import { fireChange, isDomainAuthorizedClass } from "../utils";
+
+describe("domain-authorized/utils", () => {
+  describe("fireChange", () => {
+    it("calls handleChange with a synthesized text event by default", () => {
+      const handleChange = jest.fn();
+      fireChange(handleChange, "foo", "bar");
+      expect(handleChange).toHaveBeenCalledTimes(1);
+      expect(handleChange).toHaveBeenCalledWith({
+        target: { id: "foo", value: "bar", type: "text" }
+      });
+    });
+
+    it("forwards `extra` props onto the synthesized target (checkbox case)", () => {
+      const handleChange = jest.fn();
+      fireChange(handleChange, "box", true, "checkbox", { checked: true });
+      expect(handleChange).toHaveBeenCalledTimes(1);
+      expect(handleChange).toHaveBeenCalledWith({
+        target: { id: "box", value: true, type: "checkbox", checked: true }
+      });
+    });
+  });
+
+  describe("isDomainAuthorizedClass", () => {
+    it("returns true for DOMAIN_AUTHORIZED_PROMO_CODE", () => {
+      expect(isDomainAuthorizedClass("DOMAIN_AUTHORIZED_PROMO_CODE")).toBe(
+        true
+      );
+    });
+    it("returns true for DOMAIN_AUTHORIZED_DISCOUNT_CODE", () => {
+      expect(isDomainAuthorizedClass("DOMAIN_AUTHORIZED_DISCOUNT_CODE")).toBe(
+        true
+      );
+    });
+    it("returns false for MEMBER_PROMO_CODE", () => {
+      expect(isDomainAuthorizedClass("MEMBER_PROMO_CODE")).toBe(false);
+    });
+    it("returns false for undefined", () => {
+      expect(isDomainAuthorizedClass(undefined)).toBe(false);
+    });
+    it("returns false for empty string", () => {
+      expect(isDomainAuthorizedClass("")).toBe(false);
+    });
+  });
+});
diff --git a/src/components/forms/promocode-form/forms/domain-authorized/utils.js b/src/components/forms/promocode-form/forms/domain-authorized/utils.js
new file mode 100644
index 000000000..2942c94f5
--- /dev/null
+++ b/src/components/forms/promocode-form/forms/domain-authorized/utils.js
@@ -0,0 +1,19 @@
+// React-16 event-pooling synthesizer used by every leaf in this directory.
+// Keeps `handleChange` payload shape identical to the legacy fragment's call
+// pattern so the parent PromocodeForm.handleChange contract is unchanged.
+export const fireChange = (
+  handleChange,
+  id,
+  value,
+  type = "text",
+  extra = {}
+) => {
+  handleChange({ target: { id, value, type, ...extra } });
+};
+
+// Single source of truth for the domain-authorized class-name boolean.
+// Required at all 3 sync points (validate, render, base-pc-form) — never
+// inline the string literals.
+export const isDomainAuthorizedClass = (className) =>
+  className === "DOMAIN_AUTHORIZED_PROMO_CODE" ||
+  className === "DOMAIN_AUTHORIZED_DISCOUNT_CODE";
diff --git a/src/components/forms/promocode-form/forms/index.js b/src/components/forms/promocode-form/forms/index.js
index 4beafcb50..9c1c3fb2b 100644
--- a/src/components/forms/promocode-form/forms/index.js
+++ b/src/components/forms/promocode-form/forms/index.js
@@ -49,16 +49,10 @@ export const SponsorDiscountPCForm = (props) => (
   </>
 );
 
-export const SummitPCForm = (props) => (
-  <>
-    <GenericBasePCForm {...props} />
-  </>
-);
+export const SummitPCForm = (props) => <GenericBasePCForm {...props} />;
 
 export const SummitDiscountPCForm = (props) => (
-  <>
-    <DiscountBasePCForm {...props} />
-  </>
+  <DiscountBasePCForm {...props} />
 );
 
 export const SpeakersPCForm = (props) => (
@@ -74,3 +68,11 @@ export const SpeakersDiscountPCForm = (props) => (
     <DiscountBasePCForm {...props} />
   </>
 );
+
+export const DomainAuthorizedPCForm = (props) => (
+  <GenericBasePCForm {...props} />
+);
+
+export const DomainAuthorizedDiscountPCForm = (props) => (
+  <DiscountBasePCForm {...props} />
+);
diff --git a/src/components/forms/promocode-form/forms/member-base-pc-form.js b/src/components/forms/promocode-form/forms/member-base-pc-form.js
index 26b39e412..4978b6b0a 100644
--- a/src/components/forms/promocode-form/forms/member-base-pc-form.js
+++ b/src/components/forms/promocode-form/forms/member-base-pc-form.js
@@ -1,6 +1,7 @@
 import React from "react";
 import OwnerInput from "../../../inputs/owner-input";
 import EmailRedeemForm from "./email-redeem-form";
+import AutoApplyCheckbox from "./auto-apply-checkbox";
 
 const MemberBasePCForm = (props) => (
   <>
@@ -18,6 +19,14 @@ const MemberBasePCForm = (props) => (
         />
       </div>
     </div>
+    <div className="row form-group">
+      <div className="col-md-12">
+        <AutoApplyCheckbox
+          entity={props.entity}
+          handleChange={props.handleChange}
+        />
+      </div>
+    </div>
     <EmailRedeemForm
       entity={props.entity}
       handleChange={props.handleChange}
diff --git a/src/components/forms/promocode-form/forms/speaker-base-pc-form.js b/src/components/forms/promocode-form/forms/speaker-base-pc-form.js
index 3e9bbe923..3c6458254 100644
--- a/src/components/forms/promocode-form/forms/speaker-base-pc-form.js
+++ b/src/components/forms/promocode-form/forms/speaker-base-pc-form.js
@@ -2,6 +2,7 @@ import React from "react";
 import T from "i18n-react";
 import SpeakerInput from "openstack-uicore-foundation/lib/components/inputs/speaker-input";
 import EmailRedeemForm from "./email-redeem-form";
+import AutoApplyCheckbox from "./auto-apply-checkbox";
 
 const SpeakerBasePCForm = (props) => (
   <>
@@ -17,6 +18,14 @@ const SpeakerBasePCForm = (props) => (
         />
       </div>
     </div>
+    <div className="row form-group">
+      <div className="col-md-12">
+        <AutoApplyCheckbox
+          entity={props.entity}
+          handleChange={props.handleChange}
+        />
+      </div>
+    </div>
 
     <EmailRedeemForm
       entity={props.entity}
diff --git a/src/components/forms/promocode-form/index.js b/src/components/forms/promocode-form/index.js
index e767be35b..5cfb908ea 100644
--- a/src/components/forms/promocode-form/index.js
+++ b/src/components/forms/promocode-form/index.js
@@ -14,8 +14,8 @@
 import React from "react";
 import T from "i18n-react/dist/i18n-react";
 import "awesome-bootstrap-checkbox/awesome-bootstrap-checkbox.css";
-import Dropdown from "openstack-uicore-foundation/lib/components/inputs/dropdown"
-import Input from "openstack-uicore-foundation/lib/components/inputs/text-input"
+import Dropdown from "openstack-uicore-foundation/lib/components/inputs/dropdown";
+import Input from "openstack-uicore-foundation/lib/components/inputs/text-input";
 import TagInput from "openstack-uicore-foundation/lib/components/inputs/tag-input";
 import {
   SpeakerPCForm,
@@ -27,14 +27,20 @@ import {
   SummitPCForm,
   SummitDiscountPCForm,
   SpeakersPCForm,
-  SpeakersDiscountPCForm
+  SpeakersDiscountPCForm,
+  DomainAuthorizedPCForm,
+  DomainAuthorizedDiscountPCForm
 } from "./forms";
 import {
   isEmpty,
   scrollToError,
   shallowEqual,
-  validateEmail
+  validateEmail,
+  validateAllowedEmailDomainEntry
 } from "../../../utils/methods";
+import { isDomainAuthorizedClass } from "./forms/domain-authorized/utils";
+import AllowedEmailDomainsRow from "./forms/domain-authorized/AllowedEmailDomainsRow";
+import AutoApplyCheckbox from "./forms/auto-apply-checkbox";
 import { DEFAULT_ENTITY } from "../../../reducers/promocodes/promocode-reducer";
 import FragmentParser from "../../../utils/fragmen-parser";
 import TextAreaInputWithCounter from "../../inputs/text-area-input-with-counter";
@@ -196,9 +202,32 @@ class PromocodeForm extends React.Component {
     if (entity.contact_email && !validEmail) {
       errors.contact_email = "Please enter a valid email.";
       this.setState({ errors });
+      // componentDidUpdate's scrollToError reads props.errors (server-side),
+      // so local validate() errors never trigger it. Scroll directly here.
+      // Pass a single-key object so scrollToError targets THIS field — state
+      // .errors accumulates empty-string keys for every edited field via
+      // handleChange (line 114), and scrollToError uses Object.keys()[0].
+      scrollToError({ contact_email: errors.contact_email });
       return false;
     }
 
+    const isDomainAuthorized = isDomainAuthorizedClass(entity.class_name);
+    if (isDomainAuthorized && Array.isArray(entity.allowed_email_domains)) {
+      const bad = entity.allowed_email_domains.find(
+        (d) => !validateAllowedEmailDomainEntry(d)
+      );
+      if (bad !== undefined) {
+        errors.allowed_email_domains = T.translate(
+          "edit_promocode.errors.allowed_email_domains_format"
+        );
+        this.setState({ errors });
+        scrollToError({
+          allowed_email_domains: errors.allowed_email_domains
+        });
+        return false;
+      }
+    }
+
     return true;
   }
 
@@ -213,6 +242,7 @@ class PromocodeForm extends React.Component {
       unAssignSpeaker,
       resetPromocodeForm
     } = this.props;
+    const isDomainAuthorized = isDomainAuthorizedClass(entity.class_name);
     const typeScope = this.fragmentParser.getParam("type");
 
     let promocode_class_ddl = allClasses.map((c) => ({
@@ -325,6 +355,13 @@ class PromocodeForm extends React.Component {
             />
           </div>
         </div>
+        {isDomainAuthorized && (
+          <AllowedEmailDomainsRow
+            entity={entity}
+            handleChange={this.handleChange}
+            hasErrors={this.hasErrors}
+          />
+        )}
         <div className="row form-group">
           <div className="col-md-8">
             <label htmlFor="description">
@@ -379,6 +416,14 @@ class PromocodeForm extends React.Component {
                 />
               </label>
             </div>
+            {isDomainAuthorized && (
+              <AutoApplyCheckbox
+                entity={entity}
+                handleChange={this.handleChange}
+                withCaption
+                marginTop
+              />
+            )}
           </div>
         </div>
 
@@ -514,6 +559,28 @@ class PromocodeForm extends React.Component {
           />
         )}
 
+        {entity.class_name === "DOMAIN_AUTHORIZED_PROMO_CODE" && (
+          <DomainAuthorizedPCForm
+            entity={entity}
+            summit={currentSummit}
+            handleChange={this.handleChange}
+            badgeFeatureColumns={badgeFeatureColumns}
+            badgeFeatureOptions={badgeFeatureOptions}
+            hasErrors={this.hasErrors}
+          />
+        )}
+
+        {entity.class_name === "DOMAIN_AUTHORIZED_DISCOUNT_CODE" && (
+          <DomainAuthorizedDiscountPCForm
+            entity={entity}
+            summit={currentSummit}
+            handleChange={this.handleChange}
+            badgeFeatureColumns={badgeFeatureColumns}
+            badgeFeatureOptions={badgeFeatureOptions}
+            hasErrors={this.hasErrors}
+          />
+        )}
+
         <div className="row">
           <div className="col-md-12 submit-buttons">
             <input
diff --git a/src/components/forms/ticket-type-form.js b/src/components/forms/ticket-type-form.js
index f454491f8..b598593dc 100644
--- a/src/components/forms/ticket-type-form.js
+++ b/src/components/forms/ticket-type-form.js
@@ -107,7 +107,13 @@ class TicketTypeForm extends React.Component {
     const audience_ddl = [
       { label: "With Invitation", value: "WithInvitation" },
       { label: "Without Invitation", value: "WithoutInvitation" },
-      { label: "All", value: "All" }
+      { label: "All", value: "All" },
+      // Additive audience added with the domain-authorized promo code feature.
+      // See sds/promo-codes-for-early-registration-access-summit-admin.md.
+      {
+        label: T.translate("edit_ticket_type.audience_with_promo_code"),
+        value: "WithPromoCode"
+      }
     ];
 
     return (
@@ -172,6 +178,18 @@ class TicketTypeForm extends React.Component {
             <label htmlFor="audience">
               {" "}
               {T.translate("edit_ticket_type.audience")}
+              {entity.audience === "WithPromoCode" && (
+                <>
+                  &nbsp;
+                  <i
+                    className="fa fa-info-circle"
+                    aria-hidden="true"
+                    title={T.translate(
+                      "edit_ticket_type.info_audience_with_promo_code"
+                    )}
+                  />
+                </>
+              )}
             </label>
             <Dropdown
               id="audience"
diff --git a/src/i18n/en.json b/src/i18n/en.json
index bf2730055..fe485c372 100644
--- a/src/i18n/en.json
+++ b/src/i18n/en.json
@@ -1003,15 +1003,30 @@
     "promocode_saved": "Promo Code saved successfully.",
     "promocode_created": "Promo Code created successfully.",
     "apply_to_all_tix_discounts": "Discounts",
+    "allowed_email_domains": "Allowed Email Domains",
+    "quantity_per_account": "Max Per Account",
+    "auto_apply": "Auto-apply for qualifying users",
     "placeholders": {
       "select_badge_features": "Select one or more Badge Features",
       "select_badge_type": "Select a Badge Type",
       "select_ticket_types": "Select Ticket Types",
       "select_class_name": "Select a Class",
-      "select_tags": "Select Tags"
+      "select_tags": "Select Tags",
+      "allowed_email_domains": "Add a domain, TLD, or email and press Enter"
     },
     "info": {
-      "quantity_available": "If zero is set, then Promo Code has no limit to be used"
+      "quantity_available": "If zero is set, then Promo Code has no limit to be used",
+      "allowed_email_domains": "Supported formats: @acme.com (exact domain), .edu (TLD suffix), user@example.com (exact email). Users whose email matches any entry can redeem this code.",
+      "quantity_per_account": "Maximum tickets a single account can purchase with this code. Enter 0 for unlimited.",
+      "auto_apply": "When enabled, the registration widget silently applies this code for qualifying users at checkout, without requiring them to enter it manually."
+    },
+    "captions": {
+      "allowed_email_domains": "Accepts domains (@acme.com), TLD suffixes (.edu, .gov), or exact emails (user@example.com).",
+      "auto_apply": "Silently applies this code for qualifying users when they open the registration widget.",
+      "quantity_per_account_unlimited": "0 = unlimited"
+    },
+    "errors": {
+      "allowed_email_domains_format": "Each entry must be an exact domain (@acme.com), a TLD suffix (.edu), or a full email address."
     }
   },
   "discount_ticket": {
@@ -1864,6 +1879,8 @@
     "sales_end_date": "Sale End",
     "ticket_type_saved": "Ticket Type saved successfully",
     "ticket_type_created": "Ticket Type created successfully",
+    "audience_with_promo_code": "With Promo Code",
+    "info_audience_with_promo_code": "Hidden from public listings. Only visible when a qualifying promo code includes this ticket type in its Allowed Ticket Types.",
     "placeholders": {
       "select_currency": "Select currency",
       "select_ticket_type": "Select Ticket Type",
diff --git a/src/pages/tickets/ticket-type-list-page.js b/src/pages/tickets/ticket-type-list-page.js
index 3feed9283..9da4832cb 100644
--- a/src/pages/tickets/ticket-type-list-page.js
+++ b/src/pages/tickets/ticket-type-list-page.js
@@ -318,7 +318,13 @@ const TicketTypeListPage = function ({
   const audienceDDL = [
     { label: "All", value: "All" },
     { label: "With Invitation", value: "WithInvitation" },
-    { label: "Without Invitation", value: "WithoutInvitation" }
+    { label: "Without Invitation", value: "WithoutInvitation" },
+    // Additive audience added with the domain-authorized promo code feature.
+    // See sds/promo-codes-for-early-registration-access-summit-admin.md.
+    {
+      label: T.translate("edit_ticket_type.audience_with_promo_code"),
+      value: "WithPromoCode"
+    }
   ];
 
   const badge_types_ddl = currentSummit.badge_types?.map((bt) => ({
diff --git a/src/reducers/promocodes/__tests__/promocode-reducer.test.js b/src/reducers/promocodes/__tests__/promocode-reducer.test.js
new file mode 100644
index 000000000..5f84f5366
--- /dev/null
+++ b/src/reducers/promocodes/__tests__/promocode-reducer.test.js
@@ -0,0 +1,184 @@
+import promocodeReducer, { DEFAULT_ENTITY } from "../promocode-reducer";
+import { RECEIVE_PROMOCODE } from "../../../actions/promocode-actions";
+
+describe("DEFAULT_ENTITY", () => {
+  it("includes allowed_email_domains as an empty array", () => {
+    expect(DEFAULT_ENTITY.allowed_email_domains).toEqual([]);
+  });
+
+  it("includes quantity_per_account as 0 (unlimited sentinel)", () => {
+    expect(DEFAULT_ENTITY.quantity_per_account).toBe(0);
+  });
+
+  it("includes auto_apply as false", () => {
+    expect(DEFAULT_ENTITY.auto_apply).toBe(false);
+  });
+
+  it("still contains the existing allows_to_reassign field defaulting to true", () => {
+    expect(DEFAULT_ENTITY.allows_to_reassign).toBe(true);
+  });
+});
+
+describe("RECEIVE_PROMOCODE allowed_email_domains coercion", () => {
+  it("forces null allowed_email_domains to [] (not empty string)", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: null,
+          ticket_types_rules: []
+        }
+      }
+    });
+    expect(state.entity.allowed_email_domains).toEqual([]);
+  });
+
+  it("preserves an array of allowed_email_domains from the server", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com", ".edu"],
+          ticket_types_rules: []
+        }
+      }
+    });
+    expect(state.entity.allowed_email_domains).toEqual(["@acme.com", ".edu"]);
+  });
+
+  it("forces undefined allowed_email_domains to []", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          ticket_types_rules: []
+        }
+      }
+    });
+    expect(state.entity.allowed_email_domains).toEqual([]);
+  });
+});
+
+describe("RECEIVE_PROMOCODE auto_apply / quantity_per_account type-coercion", () => {
+  // The null→"" loop at promocode-reducer.js:138-142 strips type info from
+  // legacy fields. Without post-loop normalization, mixed-typed payloads
+  // round-trip back to summit-api after a save (smarcet, PR #915 review).
+  it("forces null auto_apply to false (boolean, not empty string)", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [],
+          auto_apply: null
+        }
+      }
+    });
+    expect(state.entity.auto_apply).toBe(false);
+    expect(typeof state.entity.auto_apply).toBe("boolean");
+  });
+
+  it("preserves auto_apply=true from the server", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [],
+          auto_apply: true
+        }
+      }
+    });
+    expect(state.entity.auto_apply).toBe(true);
+  });
+
+  it("forces null quantity_per_account to 0 (number, not empty string)", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [],
+          quantity_per_account: null
+        }
+      }
+    });
+    expect(state.entity.quantity_per_account).toBe(0);
+    expect(typeof state.entity.quantity_per_account).toBe("number");
+  });
+
+  it("preserves a positive integer quantity_per_account from the server", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [],
+          quantity_per_account: 5
+        }
+      }
+    });
+    expect(state.entity.quantity_per_account).toBe(5);
+  });
+});
+
+describe("RECEIVE_PROMOCODE apply_to_all_tix derivation", () => {
+  it("derives apply_to_all_tix=false for DOMAIN_AUTHORIZED_DISCOUNT_CODE with populated ticket_types_rules", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 1,
+          class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [{ id: 10, ticket_type_id: 5, amount: 10 }]
+        }
+      }
+    });
+    expect(state.entity.apply_to_all_tix).toBe(false);
+  });
+
+  it("derives apply_to_all_tix=true for DOMAIN_AUTHORIZED_DISCOUNT_CODE with empty ticket_types_rules", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 2,
+          class_name: "DOMAIN_AUTHORIZED_DISCOUNT_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: []
+        }
+      }
+    });
+    expect(state.entity.apply_to_all_tix).toBe(true);
+  });
+
+  it("does not derive apply_to_all_tix for DOMAIN_AUTHORIZED_PROMO_CODE (access-only, no discount UI)", () => {
+    const state = promocodeReducer(undefined, {
+      type: RECEIVE_PROMOCODE,
+      payload: {
+        response: {
+          id: 3,
+          class_name: "DOMAIN_AUTHORIZED_PROMO_CODE",
+          allowed_email_domains: ["@acme.com"],
+          ticket_types_rules: [{ id: 10 }]
+        }
+      }
+    });
+    expect(state.entity.apply_to_all_tix).toBe(DEFAULT_ENTITY.apply_to_all_tix);
+  });
+});
diff --git a/src/reducers/promocodes/promocode-reducer.js b/src/reducers/promocodes/promocode-reducer.js
index f87879475..f1aeac66c 100644
--- a/src/reducers/promocodes/promocode-reducer.js
+++ b/src/reducers/promocodes/promocode-reducer.js
@@ -72,7 +72,10 @@ export const DEFAULT_ENTITY = {
   description: "",
   tags: [],
   allows_to_delegate: false,
-  allows_to_reassign: true
+  allows_to_reassign: true,
+  allowed_email_domains: [],
+  quantity_per_account: 0,
+  auto_apply: false
 };
 
 const DEFAULT_STATE = {
@@ -138,6 +141,21 @@ const promocodeReducer = (state = DEFAULT_STATE, action) => {
         }
       }
 
+      if (!Array.isArray(entity.allowed_email_domains)) {
+        entity.allowed_email_domains = [];
+      }
+
+      // Restore boolean/numeric typing after the null→"" coercion above so
+      // legacy promocodes (where these fields were null in the DB) don't
+      // round-trip mixed-typed payloads to summit-api.
+      entity.auto_apply = entity.auto_apply === true;
+      if (
+        entity.quantity_per_account === "" ||
+        entity.quantity_per_account == null
+      ) {
+        entity.quantity_per_account = 0;
+      }
+
       entity.owner = {
         email: entity.email,
         first_name: entity.first_name,
@@ -145,12 +163,16 @@ const promocodeReducer = (state = DEFAULT_STATE, action) => {
       };
       entity.speakers = state.entity.speakers;
 
+      // apply_to_all_tix is a UI-only flag; summit-api's discount-code serializer
+      // never returns it, so it must be derived from ticket_types_rules.length
+      // for every class DiscountBasePCForm can render.
       const discount_classes = [
         "SPEAKER_DISCOUNT_CODE",
         "SPONSOR_DISCOUNT_CODE",
         "MEMBER_DISCOUNT_CODE",
         "SUMMIT_DISCOUNT_CODE",
-        "SPEAKERS_DISCOUNT_CODE"
+        "SPEAKERS_DISCOUNT_CODE",
+        "DOMAIN_AUTHORIZED_DISCOUNT_CODE"
       ];
 
       if (discount_classes.includes(entity.class_name)) {
diff --git a/src/utils/__tests__/validate-allowed-email-domain-entry.test.js b/src/utils/__tests__/validate-allowed-email-domain-entry.test.js
new file mode 100644
index 000000000..bc8a05fc6
--- /dev/null
+++ b/src/utils/__tests__/validate-allowed-email-domain-entry.test.js
@@ -0,0 +1,69 @@
+import { validateAllowedEmailDomainEntry } from "../methods";
+
+describe("validateAllowedEmailDomainEntry", () => {
+  describe("valid entries", () => {
+    it.each([
+      ["@acme.com"],
+      ["@sub.acme.com"],
+      ["@a.b.c.d"],
+      ["@my-company.com"], // internal hyphen allowed
+      ["@a-b.c-d.com"], // internal hyphens across multiple labels
+      [".edu"],
+      [".co.uk"],
+      [".EDU"], // uppercase TLD accepted per server's /i flag
+      [".CO.UK"], // uppercase multi-part TLD accepted
+      [".a"],
+      ["user@example.com"],
+      ["user@my-company.example.co.uk"], // internal hyphens in email host
+      ["first.last+tag@example.co"]
+    ])("accepts %s", (entry) => {
+      expect(validateAllowedEmailDomainEntry(entry)).toBe(true);
+    });
+  });
+
+  describe("invalid entries", () => {
+    it.each([
+      [""],
+      ["   "],
+      ["acme.com"], // no leading @
+      ["@acme"], // no dot after @
+      ["@"], // empty domain
+      ["user@"], // no domain after @
+      ["@@acme.com"], // double @
+      ["user @example.com"], // whitespace
+      [null],
+      [undefined],
+      ["user@abc"], // no TLD dot
+      ["user@example..com"], // consecutive dots
+      ["user@example.com."], // trailing dot
+      ["user@acme"] // no dot, single-segment domain
+    ])("rejects %p", (entry) => {
+      expect(validateAllowedEmailDomainEntry(entry)).toBe(false);
+    });
+  });
+
+  describe("domain-only invalid entries (ALLOWED_DOMAIN_RE)", () => {
+    it.each([
+      ["@example..com"], // consecutive dots
+      ["@example.com."], // trailing dot
+      ["@.com"], // empty first label
+      ["@my_domain.com"], // underscore in label
+      ["@example_.com"], // underscore in label
+      ["@acme-.com"], // label ending in hyphen
+      ["@-acme.com"], // label starting with hyphen
+      ["@example.-com"], // sub-label starting with hyphen
+      ["@example.com-"] // last label ending with hyphen
+    ])("rejects %p", (entry) => {
+      expect(validateAllowedEmailDomainEntry(entry)).toBe(false);
+    });
+  });
+
+  describe("email invalid entries (ALLOWED_EMAIL_RE label rules)", () => {
+    it.each([
+      ["user@my_domain.com"], // underscore in domain label
+      ["user@acme-.com"] // label ending in hyphen
+    ])("rejects %p", (entry) => {
+      expect(validateAllowedEmailDomainEntry(entry)).toBe(false);
+    });
+  });
+});
diff --git a/src/utils/methods.js b/src/utils/methods.js
index 0af19ce6e..110b37fee 100644
--- a/src/utils/methods.js
+++ b/src/utils/methods.js
@@ -285,6 +285,32 @@ export const validateEmail = (email) =>
       /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
     );
 
+// Client-side form-validation for the allowed_email_domains field.
+// Stricter than summit-api's app/Rules/AllowedEmailDomainsArray.php (see SDS line 59):
+//   1. Requires at least one dot-separated label (rejects "@acme", "user@abc"),
+//      where the server's `[\w.-]+` accepts dotless suffixes.
+//   2. RFC-1035-style labels: each label must start and end with [a-z0-9] and
+//      may contain internal hyphens. Rejects underscores and labels with
+//      leading/trailing hyphens (e.g. "@acme_corp.com", "@acme-.com",
+//      "@-acme.com") that the server's `\w` / `[\w.-]` patterns admit.
+// The server remains the authority on save; the UI just blocks obvious noise.
+const ALLOWED_DOMAIN_RE =
+  /^@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/i;
+const ALLOWED_TLD_RE = /^\.[a-z0-9]+(?:\.[a-z0-9]+)*$/i;
+const ALLOWED_EMAIL_RE =
+  /^[^@\s]+@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/i;
+
+export const validateAllowedEmailDomainEntry = (entry) => {
+  if (typeof entry !== "string") return false;
+  const trimmed = entry.trim();
+  if (trimmed.length === 0) return false;
+  return (
+    ALLOWED_DOMAIN_RE.test(trimmed) ||
+    ALLOWED_TLD_RE.test(trimmed) ||
+    ALLOWED_EMAIL_RE.test(trimmed)
+  );
+};
+
 export const parseSpeakerAuditLog = (logString) => {
   const logEntries = logString.split("|");
   const userChanges = {};