diff --git a/src/api/routes/v2/membership.ts b/src/api/routes/v2/membership.ts
index d10dc457..b0bce7aa 100644
--- a/src/api/routes/v2/membership.ts
+++ b/src/api/routes/v2/membership.ts
@@ -28,8 +28,9 @@ import { getEntraIdToken } from "api/functions/entraId.js";
 import { genericConfig, roleArns } from "common/config.js";
 import { getRoleCredentials } from "api/functions/sts.js";
 import { SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { BatchGetItemCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { AppRoles } from "common/roles.js";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
 
 const membershipV2Plugin: FastifyPluginAsync = async (fastify, _options) => {
   const getAuthorizedClients = async () => {
@@ -160,6 +161,213 @@ const membershipV2Plugin: FastifyPluginAsync = async (fastify, _options) => {
         );
       },
     );
+    fastify.withTypeProvider<FastifyZodOpenApiTypeProvider>().post(
+      "/verifyBatchOfMembers",
+      {
+        schema: withRoles(
+          [
+            AppRoles.VIEW_INTERNAL_MEMBERSHIP_LIST,
+            AppRoles.VIEW_EXTERNAL_MEMBERSHIP_LIST,
+          ],
+          withTags(["Membership"], {
+            body: z.array(illinoisNetId).nonempty().max(500),
+            querystring: z.object({
+              list: z.string().min(1).optional().meta({
+                example: "built",
+                description:
+                  "Membership list to check from (defaults to ACM Paid Member list).",
+              }),
+            }),
+            summary:
+              "Check a batch of NetIDs for ACM @ UIUC paid membership (or partner organization membership) status.",
+            response: {
+              200: {
+                description: "List membership status.",
+                content: {
+                  "application/json": {
+                    schema: z
+                      .object({
+                        members: z.array(illinoisNetId),
+                        notMembers: z.array(illinoisNetId),
+                        list: z.optional(z.string().min(1)),
+                      })
+                      .meta({
+                        example: {
+                          members: ["rjjones"],
+                          notMembers: ["isbell"],
+                          list: "built",
+                        },
+                      }),
+                  },
+                },
+              },
+            },
+          }),
+        ),
+        onRequest: async (request, reply) => {
+          await fastify.authorizeFromSchema(request, reply);
+          if (!request.userRoles) {
+            throw new InternalServerError({});
+          }
+          const list = request.query.list || "acmpaid";
+          if (
+            list === "acmpaid" &&
+            !request.userRoles.has(AppRoles.VIEW_INTERNAL_MEMBERSHIP_LIST)
+          ) {
+            throw new UnauthorizedError({});
+          }
+          if (
+            list !== "acmpaid" &&
+            !request.userRoles.has(AppRoles.VIEW_EXTERNAL_MEMBERSHIP_LIST)
+          ) {
+            throw new UnauthorizedError({});
+          }
+        },
+      },
+      async (request, reply) => {
+        const list = request.query.list || "acmpaid";
+        let netIdsToCheck = [
+          ...new Set(request.body.map((id) => id.toLowerCase())),
+        ];
+
+        const members = new Set<string>();
+        const notMembers = new Set<string>();
+
+        const cacheKeys = netIdsToCheck.map((id) => `membership:${id}:${list}`);
+        if (cacheKeys.length > 0) {
+          const cachedResults = await fastify.redisClient.mget(cacheKeys);
+          const remainingNetIds: string[] = [];
+          cachedResults.forEach((result, index) => {
+            const netId = netIdsToCheck[index];
+            if (result) {
+              const { isMember } = JSON.parse(result) as { isMember: boolean };
+              if (isMember) {
+                members.add(netId);
+              } else {
+                notMembers.add(netId);
+              }
+            } else {
+              remainingNetIds.push(netId);
+            }
+          });
+          netIdsToCheck = remainingNetIds;
+        }
+
+        if (netIdsToCheck.length === 0) {
+          return reply.send({
+            members: [...members].sort(),
+            notMembers: [...notMembers].sort(),
+            list: list === "acmpaid" ? undefined : list,
+          });
+        }
+
+        const cachePipeline = fastify.redisClient.pipeline();
+
+        if (list !== "acmpaid") {
+          // can't do batch get on an index.
+          const checkPromises = netIdsToCheck.map(async (netId) => {
+            const isMember = await checkExternalMembership(
+              netId,
+              list,
+              fastify.dynamoClient,
+            );
+            if (isMember) {
+              members.add(netId);
+            } else {
+              notMembers.add(netId);
+            }
+            cachePipeline.set(
+              `membership:${netId}:${list}`,
+              JSON.stringify({ isMember }),
+              "EX",
+              MEMBER_CACHE_SECONDS,
+            );
+          });
+          await Promise.all(checkPromises);
+        } else {
+          const BATCH_SIZE = 100;
+          const foundInDynamo = new Set<string>();
+          for (let i = 0; i < netIdsToCheck.length; i += BATCH_SIZE) {
+            const batch = netIdsToCheck.slice(i, i + BATCH_SIZE);
+            const command = new BatchGetItemCommand({
+              RequestItems: {
+                [genericConfig.MembershipTableName]: {
+                  Keys: batch.map((netId) =>
+                    marshall({ email: `${netId}@illinois.edu` }),
+                  ),
+                },
+              },
+            });
+            const { Responses } = await fastify.dynamoClient.send(command);
+            const items = Responses?.[genericConfig.MembershipTableName] ?? [];
+            for (const item of items) {
+              const { email } = unmarshall(item);
+              const netId = email.split("@")[0];
+              members.add(netId);
+              foundInDynamo.add(netId);
+              cachePipeline.set(
+                `membership:${netId}:${list}`,
+                JSON.stringify({ isMember: true }),
+                "EX",
+                MEMBER_CACHE_SECONDS,
+              );
+            }
+          }
+
+          // 3. Fallback to Entra ID for remaining paid members
+          const netIdsForEntra = netIdsToCheck.filter(
+            (id) => !foundInDynamo.has(id),
+          );
+          if (netIdsForEntra.length > 0) {
+            const entraIdToken = await getEntraIdToken({
+              clients: await getAuthorizedClients(),
+              clientId: fastify.environmentConfig.AadValidClientId,
+              secretName: genericConfig.EntraSecretName,
+              logger: request.log,
+            });
+            const paidMemberGroup = fastify.environmentConfig.PaidMemberGroupId;
+            const entraCheckPromises = netIdsForEntra.map(async (netId) => {
+              const isMember = await checkPaidMembershipFromEntra(
+                netId,
+                entraIdToken,
+                paidMemberGroup,
+              );
+              if (isMember) {
+                members.add(netId);
+                // Fire-and-forget writeback to DynamoDB to warm it up
+                setPaidMembershipInTable(netId, fastify.dynamoClient).catch(
+                  (err) =>
+                    request.log.error(
+                      err,
+                      `Failed to write back Entra membership for ${netId}`,
+                    ),
+                );
+              } else {
+                notMembers.add(netId);
+              }
+              cachePipeline.set(
+                `membership:${netId}:${list}`,
+                JSON.stringify({ isMember }),
+                "EX",
+                MEMBER_CACHE_SECONDS,
+              );
+            });
+            await Promise.all(entraCheckPromises);
+          }
+        }
+
+        if (cachePipeline.length > 0) {
+          await cachePipeline.exec();
+        }
+
+        return reply.send({
+          members: [...members].sort(),
+          notMembers: [...notMembers].sort(),
+          list: list === "acmpaid" ? undefined : list,
+        });
+      },
+    );
+
     fastify.withTypeProvider<FastifyZodOpenApiTypeProvider>().get(
       "/:netId",
       {
diff --git a/src/ui/pages/membershipLists/InternalMembershipQuery.test.tsx b/src/ui/pages/membershipLists/InternalMembershipQuery.test.tsx
index 13703c34..532d8d0b 100644
--- a/src/ui/pages/membershipLists/InternalMembershipQuery.test.tsx
+++ b/src/ui/pages/membershipLists/InternalMembershipQuery.test.tsx
@@ -1,78 +1,101 @@
 import React from "react";
-import { render, screen, act } from "@testing-library/react";
+import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { vi } from "vitest";
 import { MantineProvider } from "@mantine/core";
-import { notifications } from "@mantine/notifications";
-import InternalMembershipQuery from "./InternalMembershipQuery";
-import { Modules, ModulesToHumanName } from "@common/modules";
-import { MemoryRouter } from "react-router-dom";
+import { MembershipListQuery } from "./InternalMembershipQuery";
 
-describe("InternalMembershipQuery Tests", () => {
-  const validNetIds = ["rjjones", "test2"];
-  const queryInternalMembershipMock = vi
+// Mock the useClipboard hook from @mantine/hooks
+vi.mock("@mantine/hooks", async (importOriginal) => {
+  const originalModule =
+    await importOriginal<typeof import("@mantine/hooks")>();
+  return {
+    ...originalModule,
+    useClipboard: vi.fn(() => ({
+      copy: vi.fn(),
+      copied: false,
+    })),
+  };
+});
+
+// Mock implementation for the clipboard API
+Object.assign(navigator, {
+  clipboard: {
+    writeText: vi.fn().mockResolvedValue(undefined),
+  },
+});
+
+describe("MembershipListQuery Tests", () => {
+  const queryFunctionMock = vi
     .fn()
-    .mockImplementation((netId) => validNetIds.includes(netId));
-  const renderComponent = async () => {
-    await act(async () => {
-      render(
-        <MemoryRouter>
-          <MantineProvider
-            withGlobalClasses
-            withCssVariables
-            forceColorScheme="light"
-          >
-            <InternalMembershipQuery
-              queryInternalMembership={queryInternalMembershipMock}
-            />
-          </MantineProvider>
-        </MemoryRouter>,
-      );
+    .mockImplementation(async (netIds: string[]) => {
+      const validNetIds = ["rjjones", "test2"];
+      const members = netIds.filter((id) => validNetIds.includes(id));
+      const nonMembers = netIds.filter((id) => !validNetIds.includes(id));
+      return { members, nonMembers };
     });
+
+  const renderComponent = () => {
+    render(
+      <MantineProvider>
+        <MembershipListQuery queryFunction={queryFunctionMock} />
+      </MantineProvider>,
+    );
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    // Reset notification spy
-    vi.spyOn(notifications, "show");
   });
 
-  it("renders the component correctly", async () => {
-    await renderComponent();
-
-    expect(screen.getByText("NetID")).toBeInTheDocument();
+  it("renders the component correctly", () => {
+    renderComponent();
     expect(
-      screen.getByRole("button", { name: /Query Membership/i }),
+      screen.getByLabelText(/Enter NetIDs or Illinois Emails/i),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: /Query Memberships/i }),
     ).toBeInTheDocument();
   });
 
-  it("disables query button when no NetID is provided", async () => {
-    await renderComponent();
+  it("disables the query button when the input is empty", () => {
+    renderComponent();
     expect(
-      screen.getByRole("button", { name: /Query Membership/i }),
+      screen.getByRole("button", { name: /Query Memberships/i }),
     ).toBeDisabled();
-    expect(queryInternalMembershipMock).not.toHaveBeenCalled();
   });
-  it("correctly renders members", async () => {
-    await renderComponent();
+
+  it("enables the query button when input is provided", async () => {
+    renderComponent();
     const user = userEvent.setup();
-    const textbox = screen.getByRole("textbox", { name: /NetID/i });
-    await user.type(textbox, "rjjones");
-    await user.click(screen.getByRole("button", { name: /Query Membership/i }));
-    expect(queryInternalMembershipMock).toHaveBeenCalledExactlyOnceWith(
-      "rjjones",
-    );
-    expect(screen.getByText("is a paid member.")).toBeVisible();
+    const textarea = screen.getByLabelText(/Enter NetIDs or Illinois Emails/i);
+    await user.type(textarea, "test");
+    expect(
+      screen.getByRole("button", { name: /Query Memberships/i }),
+    ).toBeEnabled();
   });
-  it("correctly renders non-members", async () => {
-    await renderComponent();
+
+  it("correctly processes input and displays members and non-members", async () => {
+    renderComponent();
     const user = userEvent.setup();
-    const textbox = screen.getByRole("textbox", { name: /NetID/i });
-    await user.type(textbox, "invalid");
-    await user.click(screen.getByRole("button", { name: /Query Membership/i }));
-    expect(queryInternalMembershipMock).toHaveBeenCalledExactlyOnceWith(
+    const textarea = screen.getByLabelText(/Enter NetIDs or Illinois Emails/i);
+    const queryButton = screen.getByRole("button", {
+      name: /Query Memberships/i,
+    });
+    const inputText = "rjjones, invalid, TEST2@illinois.edu, rjjones";
+
+    await user.type(textarea, inputText);
+    await user.click(queryButton);
+
+    expect(queryFunctionMock).toHaveBeenCalledTimes(1);
+    expect(queryFunctionMock).toHaveBeenCalledWith([
+      "rjjones",
       "invalid",
-    );
-    expect(screen.getByText("is not a paid member.")).toBeVisible();
+      "test2",
+    ]);
+
+    expect(await screen.findByText(/Paid Members \(2\)/i)).toBeVisible();
+
+    expect(screen.getByText("rjjones")).toBeVisible();
+    expect(screen.getByText("test2")).toBeVisible();
   });
 });
diff --git a/src/ui/pages/membershipLists/InternalMembershipQuery.tsx b/src/ui/pages/membershipLists/InternalMembershipQuery.tsx
index e882fde4..50105bea 100644
--- a/src/ui/pages/membershipLists/InternalMembershipQuery.tsx
+++ b/src/ui/pages/membershipLists/InternalMembershipQuery.tsx
@@ -1,33 +1,173 @@
 import { useState } from "react";
-import { TextInput, Button, Stack, Box, Text, Group } from "@mantine/core";
-import { IconCircleCheck, IconCircleX } from "@tabler/icons-react";
+import {
+  Textarea,
+  Button,
+  Stack,
+  Box,
+  Group,
+  Title,
+  Code,
+  ActionIcon,
+  Tooltip,
+} from "@mantine/core";
+import { useClipboard } from "@mantine/hooks";
+import {
+  IconCircleCheck,
+  IconCircleX,
+  IconCopy,
+  IconCheck,
+  IconMail,
+} from "@tabler/icons-react";
 
-interface InternalMembershipQueryProps {
-  queryInternalMembership: (netId: string) => Promise<boolean>;
+interface ResultSectionProps {
+  title: string;
+  items: string[];
+  color: "green" | "red";
+  icon: React.ReactNode;
+  domain?: string;
 }
 
-export const InternalMembershipQuery = ({
-  queryInternalMembership,
-}: InternalMembershipQueryProps) => {
-  const [netId, setNetId] = useState("");
+const ResultSection = ({
+  title,
+  items,
+  color,
+  icon,
+  domain,
+}: ResultSectionProps) => {
+  const clipboardIds = useClipboard({ timeout: 1000 });
+  const clipboardEmails = useClipboard({ timeout: 1000 });
+
+  const handleCopyEmails = () => {
+    if (domain) {
+      const emails = items.map((item) => `${item}@${domain}`).join(", ");
+      clipboardEmails.copy(emails);
+    }
+  };
+
+  if (!items || items.length === 0) {
+    return null;
+  }
+
+  return (
+    <Box
+      p="md"
+      bg={`${color}.7`}
+      style={{ borderRadius: "var(--mantine-radius-md)" }}
+    >
+      <Group justify="space-between" mb="xs">
+        <Group gap="xs">
+          {icon}
+          <Title order={5} c="white">
+            {title} ({items.length})
+          </Title>
+        </Group>
+        <Group gap="xs">
+          <Tooltip label="Copy as IDs">
+            <ActionIcon
+              variant="transparent"
+              color="white"
+              onClick={() => clipboardIds.copy(items.join(", "))}
+            >
+              {clipboardIds.copied ? (
+                <IconCheck size={18} />
+              ) : (
+                <IconCopy size={18} />
+              )}
+            </ActionIcon>
+          </Tooltip>
+          {domain && (
+            <Tooltip label="Copy as Emails">
+              <ActionIcon
+                variant="transparent"
+                color="white"
+                onClick={handleCopyEmails}
+              >
+                {clipboardEmails.copied ? (
+                  <IconCheck size={18} />
+                ) : (
+                  <IconMail size={18} />
+                )}
+              </ActionIcon>
+            </Tooltip>
+          )}
+        </Group>
+      </Group>
+      <Box>
+        {items.map((item) => (
+          <Code
+            key={item}
+            mr={5}
+            mb={5}
+            style={{
+              display: "inline-block",
+              color: "white",
+              backgroundColor: "rgba(0, 0, 0, 0.25)",
+            }}
+          >
+            {item}
+          </Code>
+        ))}
+      </Box>
+    </Box>
+  );
+};
+
+interface MembershipListQueryProps {
+  queryFunction: (items: string[]) => Promise<{
+    members: string[];
+    notMembers: string[];
+  }>;
+
+  domain?: string;
+  inputLabel?: string;
+  inputDescription?: string;
+  inputPlaceholder?: string;
+  ctaText?: string;
+}
+
+export const MembershipListQuery = ({
+  queryFunction,
+  domain = "illinois.edu",
+  inputLabel = "Enter NetIDs or Illinois Emails",
+  inputDescription = "Enter items separated by commas, semicolons, spaces, or newlines.",
+  inputPlaceholder = "e.g., rjjones, isbell@illinois.edu, ...",
+  ctaText = "Query Memberships",
+}: MembershipListQueryProps) => {
+  const [input, setInput] = useState("");
   const [isLoading, setIsLoading] = useState(false);
   const [result, setResult] = useState<{
-    netId: string;
-    isMember: boolean;
+    members: string[];
+    notMembers: string[];
   } | null>(null);
 
   const handleQuery = async () => {
-    if (!netId.trim()) {
+    // Input processing logic remains the same
+    const domainRegex = domain ? new RegExp(`@${domain}$`, "i") : null;
+    const processedItems = input
+      .split(/[;,\s\n]+/)
+      .map((item) => {
+        let cleanItem = item.trim().toLowerCase();
+        if (domainRegex) {
+          cleanItem = cleanItem.replace(domainRegex, "");
+        }
+        return cleanItem;
+      })
+      .filter(Boolean);
+
+    const uniqueItems = [...new Set(processedItems)];
+    if (uniqueItems.length === 0) {
       return;
     }
 
     setIsLoading(true);
     setResult(null);
+
     try {
-      const isMember = await queryInternalMembership(
-        netId.trim().toLowerCase(),
-      );
-      setResult({ netId: netId.trim().toLowerCase(), isMember });
+      const queryResult = await queryFunction(uniqueItems);
+
+      setResult(queryResult);
+    } catch (error) {
+      console.error("An error occurred during the query:", error);
     } finally {
       setIsLoading(false);
     }
@@ -35,51 +175,50 @@ export const InternalMembershipQuery = ({
 
   return (
     <Stack gap="md">
-      <TextInput
-        label="NetID"
-        placeholder="e.g., jdoe2"
-        value={netId}
-        onChange={(event) => setNetId(event.currentTarget.value)}
-        onKeyDown={(event) => {
-          if (event.key === "Enter") {
-            handleQuery();
-          }
-        }}
+      <Textarea
+        label={inputLabel}
+        description={inputDescription}
+        placeholder={inputPlaceholder}
+        value={input}
+        onChange={(event) => setInput(event.currentTarget.value)}
+        autosize
+        minRows={4}
+        maxRows={10}
       />
       <Button
         onClick={handleQuery}
         loading={isLoading}
-        disabled={!netId.trim()}
+        disabled={!input.trim()}
       >
-        Query Membership
+        {ctaText}
       </Button>
 
       {result && (
-        <Box
-          p="md"
-          mt="sm"
-          style={{ borderRadius: "var(--mantine-radius-md)" }}
-          bg={result.isMember ? "green.1" : "red.1"}
-        >
-          <Group>
-            {result.isMember ? (
+        <Stack gap="md" mt="sm">
+          <ResultSection
+            title="Paid Members"
+            items={result.members}
+            color="green"
+            icon={
               <IconCircleCheck
-                style={{ color: "var(--mantine-color-green-7)" }}
+                style={{ color: "var(--mantine-color-white)" }}
               />
-            ) : (
-              <IconCircleX style={{ color: "var(--mantine-color-red-7)" }} />
-            )}
-            <Text c={result.isMember ? "green.9" : "red.9"} fw={500} size="sm">
-              <Text span fw={700} inherit>
-                {result.netId}
-              </Text>{" "}
-              is {result.isMember ? "" : "not "}a paid member.
-            </Text>
-          </Group>
-        </Box>
+            }
+            domain={domain}
+          />
+          <ResultSection
+            title="Not Paid Members"
+            items={result.notMembers}
+            color="red"
+            icon={
+              <IconCircleX style={{ color: "var(--mantine-color-white)" }} />
+            }
+            domain={domain}
+          />
+        </Stack>
       )}
     </Stack>
   );
 };
 
-export default InternalMembershipQuery;
+export default MembershipListQuery;
diff --git a/src/ui/pages/membershipLists/MembershipListsPage.tsx b/src/ui/pages/membershipLists/MembershipListsPage.tsx
index 1b98b4e0..e0ebe045 100644
--- a/src/ui/pages/membershipLists/MembershipListsPage.tsx
+++ b/src/ui/pages/membershipLists/MembershipListsPage.tsx
@@ -1,20 +1,8 @@
 import { useState, useEffect } from "react";
-import {
-  Title,
-  Stack,
-  LoadingOverlay,
-  Container,
-  Grid, // Import Grid
-} from "@mantine/core";
+import { Title, Stack, Container, Grid } from "@mantine/core";
 import { AuthGuard } from "@ui/components/AuthGuard";
 import { useApi } from "@ui/util/api";
 import { AppRoles } from "@common/roles";
-import {
-  EntraActionResponse,
-  GroupMemberGetResponse,
-  GroupGetResponse,
-} from "@common/types/iam";
-import { transformCommaSeperatedName } from "@common/utils";
 import { notifications } from "@mantine/notifications";
 import { IconAlertCircle } from "@tabler/icons-react";
 import ExternalMemberListManagement from "./ExternalMemberListManagement";
@@ -48,20 +36,17 @@ export const ManageExternalMembershipPage = () => {
     fetchLists();
   }, [api]);
 
-  const queryInternalMembership = async (netId: string) => {
+  const queryInternalMembership = async (netIds: string[]) => {
     try {
-      const result = await api.get<{ netId: string; isPaidMember: boolean }>(
-        `/api/v2/membership/${netId}`,
-      );
-      return result.data.isPaidMember;
+      const result = await api.post<{
+        members: string[];
+        notMembers: string[];
+      }>(`/api/v2/membership/verifyBatchOfMembers`, netIds);
+      return result.data;
     } catch (error: any) {
-      if (error instanceof AxiosError && error.status === 400) {
-        // Invalid NetID.
-        return false;
-      }
       console.error("Failed to check internal membership:", error);
       notifications.show({
-        title: "Failed to get query membership list.",
+        title: "Failed to query membership list.",
         message: "Please try again or contact support.",
         color: "red",
         icon: <IconAlertCircle size={16} />,
@@ -129,7 +114,7 @@ export const ManageExternalMembershipPage = () => {
             <Stack>
               <Title order={2}>Query ACM Paid Membership List</Title>
               <InternalMembershipQuery
-                queryInternalMembership={queryInternalMembership}
+                queryFunction={queryInternalMembership}
               />
             </Stack>
           </AuthGuard>
diff --git a/tests/e2e/membershipLists.spec.ts b/tests/e2e/membershipLists.spec.ts
index 5a14e637..21c7831c 100644
--- a/tests/e2e/membershipLists.spec.ts
+++ b/tests/e2e/membershipLists.spec.ts
@@ -9,24 +9,16 @@ describe("Internal Membership tests", () => {
     await becomeUser(page);
     await page.locator("a").filter({ hasText: "Membership Lists" }).click();
     await page
-      .getByRole("textbox", { name: "NetID", exact: true })
-      .fill("dsingh14");
-    await page
-      .getByRole("button", { name: "Query Membership", exact: true })
-      .click();
-    await expect(page.getByText("dsingh14 is a paid member.")).toBeVisible();
-    await page.getByRole("textbox", { name: "NetID", exact: true }).fill("z");
-    await page
-      .getByRole("button", { name: "Query Membership", exact: true })
+      .getByRole("textbox", { name: "Enter NetIDs or Illinois" })
       .click();
-    await expect(page.getByText("z is not a paid member.")).toBeVisible();
     await page
-      .getByRole("textbox", { name: "NetID", exact: true })
-      .fill("rjjones");
-    await page
-      .getByRole("button", { name: "Query Membership", exact: true })
-      .click();
-    await expect(page.getByText("rjjones is not a paid member.")).toBeVisible();
+      .getByRole("textbox", { name: "Enter NetIDs or Illinois" })
+      .fill("dsingh14;invalid");
+    await page.getByRole("button", { name: "Query Memberships" }).click();
+    await expect(page.locator("#root")).toContainText("Paid Members (1)");
+    await expect(page.locator("#root")).toContainText("Not Paid Members (1)");
+    await expect(page.locator("#root")).toContainText("dsingh14");
+    await expect(page.locator("#root")).toContainText("invalid");
   });
 });
 
diff --git a/tests/unit/membership.test.ts b/tests/unit/membership.test.ts
index 58c18daf..6bab442a 100644
--- a/tests/unit/membership.test.ts
+++ b/tests/unit/membership.test.ts
@@ -4,6 +4,7 @@ import { EventGetResponse } from "../../src/api/routes/events.js";
 import { afterEach, describe } from "node:test";
 import { setPaidMembershipInTable } from "../../src/api/functions/membership.js";
 import {
+  BatchGetItemCommand,
   BatchWriteItemCommand,
   DynamoDBClient,
   QueryCommand,
@@ -304,6 +305,32 @@ describe("Test membership routes", async () => {
     });
     expect(response.statusCode).toBe(201);
   });
+  test("Test getting members/non-members in batch.", async () => {
+    ddbMock.on(BatchGetItemCommand).resolvesOnce({
+      Responses: {
+        [genericConfig.MembershipTableName]: [
+          marshall({
+            email: "valid@illinois.edu",
+          }),
+        ],
+      },
+    });
+    const testJwt = createJwt();
+    const response = await app.inject({
+      method: "POST",
+      url: "/api/v2/membership/verifyBatchOfMembers",
+      headers: {
+        authorization: `Bearer ${testJwt}`,
+      },
+      body: ["valid", "invalid"],
+    });
+    expect(response.statusCode).toBe(200);
+    const responseDataJson = (await response.json()) as EventGetResponse;
+    expect(responseDataJson).toEqual({
+      members: ["valid"],
+      notMembers: ["invalid"],
+    });
+  });
   afterEach(async () => {
     ddbMock.reset();
   });