diff --git a/packages/studio/src/components/AddPageButton/BasicPageDataCollector.tsx b/packages/studio/src/components/AddPageButton/BasicPageDataCollector.tsx
index 705700e82..b5d51c870 100644
--- a/packages/studio/src/components/AddPageButton/BasicPageDataCollector.tsx
+++ b/packages/studio/src/components/AddPageButton/BasicPageDataCollector.tsx
@@ -5,6 +5,7 @@ import useStudioStore from "../../store/useStudioStore";
 import AddPageContext from "./AddPageContext";
 import TemplateExpressionFormatter from "../../utils/TemplateExpressionFormatter";
 import { GetPathVal, PropValueKind } from "@yext/studio-plugin";
+import PageDataValidator from "../../utils/PageDataValidator";
 
 type BasicPageData = {
   pageName: string;
@@ -22,6 +23,10 @@ export default function BasicPageDataCollector({
   );
   const { state } = useContext(AddPageContext);
   const isEntityPage = isPagesJSRepo && !state.isStatic;
+  const pageDataValidator = useMemo(
+    () => new PageDataValidator(isEntityPage),
+    [isEntityPage]
+  );
 
   const formData: FormData<BasicPageData> = useMemo(
     () => ({
@@ -37,10 +42,18 @@ export default function BasicPageDataCollector({
 
   const onConfirm = useCallback(
     async (data: BasicPageData) => {
+      const getPathValue = data.url
+        ? createGetPathVal(data.url, isEntityPage)
+        : undefined;
+      const validationResult = pageDataValidator.validate({
+        ...data,
+        url: getPathValue?.value,
+      });
+      if (!validationResult.valid) {
+        setErrorMessage(validationResult.errorMessages.join("\r\n"));
+        return false;
+      }
       try {
-        const getPathValue = data.url
-          ? createGetPathVal(data.url, isEntityPage)
-          : undefined;
         await handleConfirm(data.pageName, getPathValue);
         return true;
       } catch (err: unknown) {
@@ -52,7 +65,7 @@ export default function BasicPageDataCollector({
         }
       }
     },
-    [handleConfirm, isEntityPage]
+    [handleConfirm, isEntityPage, pageDataValidator]
   );
 
   const transformOnChangeValue = useCallback(
diff --git a/packages/studio/src/components/PageSettingsButton/EntityPageModal.tsx b/packages/studio/src/components/PageSettingsButton/EntityPageModal.tsx
index c0563e70b..97e23ede2 100644
--- a/packages/studio/src/components/PageSettingsButton/EntityPageModal.tsx
+++ b/packages/studio/src/components/PageSettingsButton/EntityPageModal.tsx
@@ -1,5 +1,5 @@
 import useStudioStore from "../../store/useStudioStore";
-import { useCallback, useMemo } from "react";
+import { useCallback, useMemo, useState } from "react";
 import FormModal, { FormData } from "../common/FormModal";
 import { GetPathVal, PropValueKind, ResponseType } from "@yext/studio-plugin";
 import TemplateExpressionFormatter from "../../utils/TemplateExpressionFormatter";
@@ -10,6 +10,7 @@ import StreamScopeParser, {
 import { PageSettingsModalProps } from "./PageSettingsButton";
 import { StaticPageSettings } from "./StaticPageModal";
 import { streamScopeFormData } from "../AddPageButton/StreamScopeCollector";
+import PageDataValidator from "../../utils/PageDataValidator";
 import { toast } from "react-toastify";
 import { isEqual } from "lodash";
 
@@ -38,28 +39,34 @@ export default function EntityPageModal({
     store.pages.updateStreamScope,
     store.actions.generateTestData,
   ]);
-  const isPathUndefined = !currGetPathValue;
+  const [errorMessage, setErrorMessage] = useState<string>("");
+  const pageDataValidator = useMemo(() => new PageDataValidator(true), []);
+  const isURLEditable = useMemo(
+    () => pageDataValidator.checkIsURLEditable(currGetPathValue?.value),
+    [currGetPathValue?.value, pageDataValidator]
+  );
 
   const initialFormValue: EntityPageSettings = useMemo(
     () => ({
-      url: getUrlDisplayValue(currGetPathValue),
+      url: isURLEditable ? getUrlDisplayValue(currGetPathValue) : "",
       ...StreamScopeParser.convertStreamScopeToForm(streamScope),
     }),
-    [currGetPathValue, streamScope]
+    [currGetPathValue, streamScope, isURLEditable]
   );
 
   const entityFormData: FormData<EntityPageSettings> = useMemo(
     () => ({
       url: {
         description: "URL Slug",
-        optional: isPathUndefined,
-        placeholder: isPathUndefined
-          ? "<URL slug is defined by developer>"
-          : "",
+        optional: !isURLEditable,
+        placeholder: isURLEditable
+          ? ""
+          : "<URL slug is not editable in Studio. Consult a developer>",
+        disabled: !isURLEditable,
       },
       ...streamScopeFormData,
     }),
-    [isPathUndefined]
+    [isURLEditable]
   );
 
   const handleModalSave = useCallback(
@@ -68,6 +75,13 @@ export default function EntityPageModal({
         kind: PropValueKind.Expression,
         value: TemplateExpressionFormatter.getRawValue(form.url),
       };
+      const validationResult = pageDataValidator.validate({
+        url: getPathValue.value,
+      });
+      if (!validationResult.valid) {
+        setErrorMessage(validationResult.errorMessages.join("\r\n"));
+        return false;
+      }
       if (form.url || currGetPathValue) {
         updateGetPathValue(pageName, getPathValue);
       }
@@ -91,6 +105,7 @@ export default function EntityPageModal({
       updateStreamScope,
       currGetPathValue,
       pageName,
+      pageDataValidator,
       generateTestData,
       streamScope,
     ]
@@ -103,6 +118,7 @@ export default function EntityPageModal({
       instructions="Use the optional fields below to specify which entities this page can access. Values should be separated by commas. Changing the scope of the stream (entity IDs, entity type IDs, and saved filter IDs) may result in entity data references being invalid or out of date."
       formData={entityFormData}
       initialFormValue={initialFormValue}
+      errorMessage={errorMessage}
       requireChangesToSubmit={true}
       handleClose={handleClose}
       handleConfirm={handleModalSave}
diff --git a/packages/studio/src/components/PageSettingsButton/StaticPageModal.tsx b/packages/studio/src/components/PageSettingsButton/StaticPageModal.tsx
index fd06a99c1..71078d6cd 100644
--- a/packages/studio/src/components/PageSettingsButton/StaticPageModal.tsx
+++ b/packages/studio/src/components/PageSettingsButton/StaticPageModal.tsx
@@ -1,8 +1,9 @@
 import useStudioStore from "../../store/useStudioStore";
-import { useCallback, useMemo } from "react";
+import { useCallback, useMemo, useState } from "react";
 import FormModal, { FormData } from "../common/FormModal";
 import { GetPathVal, PropValueKind } from "@yext/studio-plugin";
 import { PageSettingsModalProps } from "./PageSettingsButton";
+import PageDataValidator from "../../utils/PageDataValidator";
 
 export type StaticPageSettings = {
   url: string;
@@ -21,7 +22,12 @@ export default function StaticPageModal({
     store.pages.pages[pageName].pagesJS?.getPathValue,
     store.pages.updateGetPathValue,
   ]);
-  const isPathUndefined = !currGetPathValue;
+  const [errorMessage, setErrorMessage] = useState<string>("");
+  const pageDataValidator = useMemo(() => new PageDataValidator(), []);
+  const isURLEditable = useMemo(
+    () => pageDataValidator.checkIsURLEditable(currGetPathValue?.value),
+    [currGetPathValue?.value, pageDataValidator]
+  );
 
   const initialFormValue: StaticPageSettings = useMemo(
     () => ({ url: currGetPathValue?.value ?? "" }),
@@ -32,13 +38,14 @@ export default function StaticPageModal({
     () => ({
       url: {
         description: "URL Slug",
-        optional: isPathUndefined,
-        placeholder: isPathUndefined
-          ? "<URL slug is defined by developer>"
-          : "",
+        optional: !isURLEditable,
+        placeholder: isURLEditable
+          ? ""
+          : "<URL slug is not editable in Studio. Consult a developer>",
+        disabled: !isURLEditable,
       },
     }),
-    [isPathUndefined]
+    [isURLEditable]
   );
 
   const handleModalSave = useCallback(
@@ -47,10 +54,17 @@ export default function StaticPageModal({
         kind: PropValueKind.Literal,
         value: form.url,
       };
+      const validationResult = pageDataValidator.validate({
+        url: getPathValue.value,
+      });
+      if (!validationResult.valid) {
+        setErrorMessage(validationResult.errorMessages.join("\r\n"));
+        return false;
+      }
       updateGetPathValue(pageName, getPathValue);
       return true;
     },
-    [updateGetPathValue, pageName]
+    [updateGetPathValue, pageName, pageDataValidator]
   );
 
   return (
@@ -59,6 +73,7 @@ export default function StaticPageModal({
       title="Page Settings"
       formData={staticFormData}
       initialFormValue={initialFormValue}
+      errorMessage={errorMessage}
       requireChangesToSubmit={true}
       handleClose={handleClose}
       handleConfirm={handleModalSave}
diff --git a/packages/studio/src/components/common/FormModal.tsx b/packages/studio/src/components/common/FormModal.tsx
index 78e2d273e..ca9cfd411 100644
--- a/packages/studio/src/components/common/FormModal.tsx
+++ b/packages/studio/src/components/common/FormModal.tsx
@@ -12,6 +12,7 @@ export type FormData<T extends Form> = {
     optional?: boolean;
     placeholder?: string;
     tooltip?: string;
+    disabled?: boolean;
   };
 };
 
@@ -149,6 +150,7 @@ function FormField({
   description,
   placeholder,
   tooltip,
+  disabled,
 }: {
   field: string;
   value: string;
@@ -157,6 +159,7 @@ function FormField({
   description: string;
   placeholder?: string;
   tooltip?: string;
+  disabled?: boolean;
 }): JSX.Element {
   const handleChange = useCallback(
     (e: ChangeEvent<HTMLInputElement>) => {
@@ -182,6 +185,7 @@ function FormField({
         placeholder={placeholder}
         value={value}
         onChange={handleChange}
+        disabled={disabled}
       />
     </>
   );
diff --git a/packages/studio/src/components/common/Modal.tsx b/packages/studio/src/components/common/Modal.tsx
index 4bd3fa51e..3ba2e1478 100644
--- a/packages/studio/src/components/common/Modal.tsx
+++ b/packages/studio/src/components/common/Modal.tsx
@@ -71,7 +71,9 @@ export default function Modal({
       {body}
       <div className={footerClasses}>
         {errorMessage && (
-          <div className="flex justify-start text-red-600">{errorMessage}</div>
+          <div className="flex justify-start whitespace-pre-wrap text-red-600">
+            {errorMessage}
+          </div>
         )}
         <div className="flex justify-end">
           <button className="ml-2" onClick={handleClose}>
diff --git a/packages/studio/src/store/StudioActions/CreatePageAction.ts b/packages/studio/src/store/StudioActions/CreatePageAction.ts
index 5e1bb0e51..b7487bd3f 100644
--- a/packages/studio/src/store/StudioActions/CreatePageAction.ts
+++ b/packages/studio/src/store/StudioActions/CreatePageAction.ts
@@ -74,30 +74,9 @@ function validate(
   getPathValue?: GetPathVal
 ) {
   if (isPagesJSRepo && !getPathValue) {
-    throw new Error("Error adding page: a getPath value is required.");
-  }
-  if (!pageName) {
-    throw new Error("Error adding page: a pageName is required.");
+    throw new Error("A getPath value is required.");
   }
   if (!filepath.startsWith(pagesPath)) {
-    throw new Error(`Error adding page: pageName is invalid: ${pageName}`);
-  }
-  const errorChars = pageName.match(/[\\/?%*:|"<>]/g);
-  if (errorChars) {
-    throw new Error(
-      `Error adding page: pageName ${pageName} cannot contain the characters: ${[
-        ...new Set(errorChars),
-      ]}`
-    );
-  }
-  if (pageName.endsWith(".")) {
-    throw new Error(
-      `Error adding page: pageName ${pageName} cannot end with a period.`
-    );
-  }
-  if (pageName.length > 255) {
-    throw new Error(
-      "Error adding page: pageName must be 255 characters or less."
-    );
+    throw new Error(`Page name is invalid: ${pageName}`);
   }
 }
diff --git a/packages/studio/src/store/slices/pages/createPageSlice.ts b/packages/studio/src/store/slices/pages/createPageSlice.ts
index 4f2847818..2ce693c40 100644
--- a/packages/studio/src/store/slices/pages/createPageSlice.ts
+++ b/packages/studio/src/store/slices/pages/createPageSlice.ts
@@ -35,9 +35,7 @@ export const createPageSlice: SliceCreator<PageSlice> = (set, get) => {
   const pageActions = {
     addPage: (pageName: string, page: PageState) => {
       if (get().pages[pageName]) {
-        throw new Error(
-          `Error adding page: page name "${pageName}" is already used.`
-        );
+        throw new Error(`Page name "${pageName}" is already used.`);
       }
 
       set((store) => {
diff --git a/packages/studio/src/utils/PageDataValidator.ts b/packages/studio/src/utils/PageDataValidator.ts
new file mode 100644
index 000000000..903075e12
--- /dev/null
+++ b/packages/studio/src/utils/PageDataValidator.ts
@@ -0,0 +1,87 @@
+export interface ValidationResult {
+  valid: boolean;
+  errorMessages: string[];
+}
+
+/**
+ * PageDataValidator contains various static utility methods
+ * for validation of user-inputted page data.
+ */
+export default class PageDataValidator {
+  private isEntityPage = false;
+
+  constructor(isEntityPage?: boolean) {
+    if (isEntityPage) {
+      this.isEntityPage = isEntityPage;
+    }
+  }
+
+  checkIsURLEditable(url?: string) {
+    if (!url) {
+      return false;
+    }
+    const result: ValidationResult = this.validate({ url });
+    return result.valid;
+  }
+  /**
+   * Throws an error if the user-inputted page data is invalid.
+   */
+  validate(pageData: { pageName?: string; url?: string }): ValidationResult {
+    const errorMessages: string[] = [];
+    if (pageData.pageName !== undefined)
+      errorMessages.push(...this.validatePageName(pageData.pageName));
+    if (pageData.url !== undefined)
+      errorMessages.push(
+        ...this.validateURLSlug(pageData.url, this.isEntityPage)
+      );
+    return {
+      valid: errorMessages.length === 0,
+      errorMessages: errorMessages,
+    } as ValidationResult;
+  }
+
+  /**
+   * Throws an error if the page name is invalid.
+   */
+  private validatePageName(pageName: string) {
+    const errorMessages: string[] = [];
+    if (!pageName) {
+      errorMessages.push("A page name is required.");
+    }
+    const errorChars = pageName.match(/[\\/?%*:|"<>]/g);
+    if (errorChars) {
+      errorMessages.push(
+        `Page name cannot contain the characters: ${[
+          ...new Set(errorChars),
+        ].join("")}`
+      );
+    }
+    if (pageName.endsWith(".")) {
+      errorMessages.push(`Page name cannot end with a period.`);
+    }
+    if (pageName.length > 255) {
+      errorMessages.push("Page name must be 255 characters or less.");
+    }
+    return errorMessages;
+  }
+
+  /**
+   * Throws an error if the URL Slug is invalid.
+   */
+  private validateURLSlug(input: string, isEntityPage?: boolean) {
+    const cleanInput = isEntityPage
+      ? input.replace(/\${document\..*?}/g, "")
+      : input;
+    const blackListURLChars = new RegExp(/[ <>""''|\\{}[\]]/g);
+    const errorChars = cleanInput.match(blackListURLChars);
+    const errorMessages: string[] = [];
+    if (errorChars) {
+      errorMessages.push(
+        `URL slug contains invalid characters: ${[...new Set(errorChars)].join(
+          ""
+        )}`
+      );
+    }
+    return errorMessages;
+  }
+}
diff --git a/packages/studio/tests/components/AddPageFlow/AddPageButton.test.tsx b/packages/studio/tests/components/AddPageFlow/AddPageButton.test.tsx
index 804d2999b..353a73b97 100644
--- a/packages/studio/tests/components/AddPageFlow/AddPageButton.test.tsx
+++ b/packages/studio/tests/components/AddPageFlow/AddPageButton.test.tsx
@@ -222,6 +222,25 @@ describe("PagesJS repo", () => {
         __: expect.anything(),
       });
     });
+
+    it("gives an error if the URL slug contains document expression and is invalid", async () => {
+      render(<AddPageButton />);
+      const addPageButton = screen.getByRole("button");
+      await userEvent.click(addPageButton);
+      await selectEntityPageType();
+      const nextButton = screen.getByRole("button", { name: "Next" });
+      await userEvent.click(nextButton);
+      await userEvent.click(nextButton);
+      await specifyName();
+      await specifyUrl("=<>[[[[field]]");
+      const saveButton = screen.getByRole("button", { name: "Save" });
+      await userEvent.click(saveButton);
+
+      expect(
+        screen.getByText("URL slug contains invalid characters: <>")
+      ).toBeDefined();
+      expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
+    });
   });
 });
 
@@ -235,9 +254,7 @@ describe("errors", () => {
     const saveButton = screen.getByRole("button", { name: "Save" });
     await userEvent.click(saveButton);
     expect(
-      screen.getByText(
-        'Error adding page: page name "universal" is already used.'
-      )
+      screen.getByText('Page name "universal" is already used.')
     ).toBeDefined();
   });
 
@@ -246,11 +263,11 @@ describe("errors", () => {
     const addPageButton = screen.getByRole("button");
     await userEvent.click(addPageButton);
     const textbox = screen.getByRole("textbox");
-    await userEvent.type(textbox, "../test");
+    await userEvent.type(textbox, "***");
     const saveButton = screen.getByRole("button", { name: "Save" });
     await userEvent.click(saveButton);
     expect(
-      screen.getByText("Error adding page: pageName is invalid: ../test")
+      screen.getByText("Page name cannot contain the characters: *")
     ).toBeDefined();
   });
 });
diff --git a/packages/studio/tests/components/PageSettingsButton.test.tsx b/packages/studio/tests/components/PageSettingsButton.test.tsx
index 134c39c86..64d657029 100644
--- a/packages/studio/tests/components/PageSettingsButton.test.tsx
+++ b/packages/studio/tests/components/PageSettingsButton.test.tsx
@@ -4,7 +4,6 @@ import useStudioStore from "../../src/store/useStudioStore";
 import mockStore from "../__utils__/mockStore";
 import PageSettingsButton from "../../src/components/PageSettingsButton/PageSettingsButton";
 import { PageState, PropValueKind, ResponseType } from "@yext/studio-plugin";
-import TemplateExpressionFormatter from "../../src/utils/TemplateExpressionFormatter";
 import { checkTooltipFunctionality } from "../__utils__/helpers";
 import * as sendMessageModule from "../../src/messaging/sendMessage";
 import { StudioStore } from "../../src/store/models/StudioStore";
@@ -52,6 +51,16 @@ beforeEach(() => {
             },
           },
         },
+        invalid_slug: {
+          ...basePageState,
+          pagesJS: {
+            getPathValue: {
+              kind: PropValueKind.Expression,
+              value: "iaminvalid<>||||$|{document.no}",
+            },
+            streamScope: {},
+          },
+        },
       },
     },
     studioConfig: {
@@ -212,7 +221,7 @@ it("shows a tooltip when hovering over the label", async () => {
   );
 });
 
-async function editUndefinedURL(pageName: string, isEntityPage: boolean) {
+async function cannotEditURL(pageName: string) {
   const updateGetPathValueSpy = jest.spyOn(
     useStudioStore.getState().pages,
     "updateGetPathValue"
@@ -221,27 +230,42 @@ async function editUndefinedURL(pageName: string, isEntityPage: boolean) {
   const pageSettingsButton = screen.getByRole("button");
   await userEvent.click(pageSettingsButton);
   const urlTextbox = screen.getByPlaceholderText(
-    "<URL slug is defined by developer>"
+    "<URL slug is not editable in Studio. Consult a developer>"
   );
-  const testUrl = "test-url";
-  await userEvent.type(urlTextbox, testUrl);
+  expect(urlTextbox).toBeDisabled();
   const saveButton = screen.getByRole("button", { name: "Save" });
-  await userEvent.click(saveButton);
-  const updatedUrl = isEntityPage
-    ? TemplateExpressionFormatter.addBackticks(testUrl)
-    : testUrl;
-  expect(updateGetPathValueSpy).toBeCalledWith(pageName, {
-    kind: isEntityPage ? PropValueKind.Expression : PropValueKind.Literal,
-    value: updatedUrl,
-  });
-  await userEvent.click(pageSettingsButton);
-  expect(urlTextbox).toHaveValue(testUrl);
+  expect(saveButton).toBeDisabled();
+  expect(updateGetPathValueSpy).toBeCalledTimes(0);
 }
 
-it("displays URL placeholder and can edit URL when static page's getPath value is undefined", async () => {
-  await editUndefinedURL("index", false);
+it("displays URL placeholder and cannot edit URL when static page's getPath value is undefined", async () => {
+  await cannotEditURL("index");
 });
 
-it("displays URL placeholder and can edit URL when entity page's getPath value is undefined", async () => {
-  await editUndefinedURL("fruits", true);
+it("displays URL placeholder and cannot edit URL when entity page's getPath value is undefined", async () => {
+  await cannotEditURL("fruits");
+});
+
+it("displays URL placeholder and cannot edit URL when entity page's getPath value is invalid", async () => {
+  await cannotEditURL("invalid_slug");
+});
+
+it("throws an error when user enters an invalid URL slug and allows user to fix", async () => {
+  render(<PageSettingsButton pageName="product" />);
+  const pageSettingsButton = screen.getByRole("button");
+  await userEvent.click(pageSettingsButton);
+  const urlTextbox = screen.getByRole("textbox", { name: "URL Slug" });
+  expect(urlTextbox).toHaveValue("[[slug]]");
+  await userEvent.type(urlTextbox, "{backspace}");
+  const saveButton = screen.getByRole("button", { name: "Save" });
+  await userEvent.click(saveButton);
+  expect(saveButton).toBeDisabled();
+  expect(
+    screen.getByText("URL slug contains invalid characters: []")
+  ).toBeDefined();
+  await userEvent.type(urlTextbox, "]-[[field]]");
+  expect(
+    screen.queryByText("URL slug contains invalid characters: []")
+  ).toBeNull();
+  expect(saveButton).toBeEnabled();
 });
diff --git a/packages/studio/tests/store/StudioActions/createPage.test.ts b/packages/studio/tests/store/StudioActions/createPage.test.ts
index e2bcc1465..9005eb46a 100644
--- a/packages/studio/tests/store/StudioActions/createPage.test.ts
+++ b/packages/studio/tests/store/StudioActions/createPage.test.ts
@@ -6,47 +6,12 @@ import * as sendMessageModule from "../../../src/messaging/sendMessage";
 describe("non-PagesJS repo", () => {
   it("gives an error for a relative filepath", async () => {
     const createPage = useStudioStore.getState().actions.createPage("../test");
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: pageName is invalid: ../test"
-    );
+    await expect(createPage).rejects.toThrow("Page name is invalid: ../test");
   });
 
-  it("gives an error for an empty string pagename", async () => {
-    const createPage = useStudioStore.getState().actions.createPage("");
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: a pageName is required."
-    );
-  });
-
-  it("gives an error for a pagename with only asterisks", async () => {
-    const createPage = useStudioStore.getState().actions.createPage("***");
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: pageName *** cannot contain the characters: *"
-    );
-  });
-
-  it("gives an error for a pagename with multiple special characters", async () => {
-    const createPage = useStudioStore
-      .getState()
-      .actions.createPage('test\\|"<>?');
-    await expect(createPage).rejects.toThrow(
-      'Error adding page: pageName test\\|"<>? cannot contain the characters: \\,|,",<,>,?'
-    );
-  });
-
-  it("gives an error for a pagename ending in a period", async () => {
-    const createPage = useStudioStore.getState().actions.createPage("test.");
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: pageName test. cannot end with a period."
-    );
-  });
-
-  it("gives an error for a pagename 256 characters long", async () => {
-    const longName = "a".repeat(256);
-    const createPage = useStudioStore.getState().actions.createPage(longName);
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: pageName must be 255 characters or less."
-    );
+  it("gives an error for an invalid pagename", async () => {
+    const createPage = useStudioStore.getState().actions.createPage("../test");
+    await expect(createPage).rejects.toThrow("Page name is invalid: ../test");
   });
 
   it("adds the new page name to pagesToUpdate", async () => {
@@ -98,9 +63,7 @@ describe("PagesJS repo", () => {
 
   it("gives an error if no getPath value is passed in", async () => {
     const createPage = useStudioStore.getState().actions.createPage("test");
-    await expect(createPage).rejects.toThrow(
-      "Error adding page: a getPath value is required."
-    );
+    await expect(createPage).rejects.toThrow("A getPath value is required.");
   });
 
   it("adds a page with getPathValue to pages record", async () => {
diff --git a/packages/studio/tests/store/createPageSlice/pageActions.test.ts b/packages/studio/tests/store/createPageSlice/pageActions.test.ts
index de9ca1421..354566463 100644
--- a/packages/studio/tests/store/createPageSlice/pageActions.test.ts
+++ b/packages/studio/tests/store/createPageSlice/pageActions.test.ts
@@ -51,9 +51,7 @@ describe("addPage", () => {
         cssImports: [],
         filepath: "/blah/universal.tsx",
       });
-    expect(action).toThrowError(
-      'Error adding page: page name "universal" is already used.'
-    );
+    expect(action).toThrowError('Page name "universal" is already used.');
   });
 });
 
diff --git a/packages/studio/tests/utils/PageDataValidator.test.ts b/packages/studio/tests/utils/PageDataValidator.test.ts
new file mode 100644
index 000000000..382d536aa
--- /dev/null
+++ b/packages/studio/tests/utils/PageDataValidator.test.ts
@@ -0,0 +1,66 @@
+import PageDataValidator, {
+  ValidationResult,
+} from "../../src/utils/PageDataValidator";
+
+describe("URL slug validation", () => {
+  function expectURLError(
+    input: string,
+    errorMessage: string[],
+    isEntityPage?: boolean
+  ) {
+    const validator = new PageDataValidator(isEntityPage);
+    const result: ValidationResult = validator.validate({ url: input });
+    expect(result).toEqual({ valid: false, errorMessages: errorMessage });
+  }
+
+  it("gives an error for document expression in a static field", () => {
+    const errorMessage = "URL slug contains invalid characters: {}";
+    expectURLError("${document.field}", [errorMessage]);
+  });
+
+  it("does not give an error for valid document expression in an entity page", () => {
+    const validator = new PageDataValidator(true);
+    const result = validator.validate({
+      url: "${document.field}-${document.slug}",
+    });
+    expect(result).toEqual({ valid: true, errorMessages: [] });
+  });
+
+  it("gives an error for a document expression with invalid characters", () => {
+    const errorMessage = "URL slug contains invalid characters: <>[]{}";
+    expectURLError(
+      "${document.field}<>[[]]{}${document.slug}",
+      [errorMessage],
+      true
+    );
+  });
+});
+
+describe("page name validation", () => {
+  function expectPageNameError(input: string, errorMessage: string[]) {
+    const validator = new PageDataValidator();
+    const result: ValidationResult = validator.validate({ pageName: input });
+    expect(result).toEqual({ valid: false, errorMessages: errorMessage });
+  }
+
+  it("gives an error for an empty string pagename", () => {
+    const errorMessage = "A page name is required.";
+    expectPageNameError("", [errorMessage]);
+  });
+
+  it("gives an error for a pagename with multiple special characters", () => {
+    const errorMessage = 'Page name cannot contain the characters: \\|"<>?';
+    expectPageNameError('test\\|"<>?', [errorMessage]);
+  });
+
+  it("gives an error for a pagename ending in a period", () => {
+    const errorMessage = "Page name cannot end with a period.";
+    expectPageNameError("test.", [errorMessage]);
+  });
+
+  it("gives an error for a pagename 256 characters long", () => {
+    const longName = "a".repeat(256);
+    const errorMessage = "Page name must be 255 characters or less.";
+    expectPageNameError(longName, [errorMessage]);
+  });
+});