diff --git a/README.md b/README.md
index 80c8902..443370e 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ You can fight against AI usage or learn to embrace it as a new way of working. I
 - **Label settings** -- tape size, margins, minimum length, justify, foreground/background colors
 - **Per-widget font styles** -- each text widget can have its own font style, scale, frame, and alignment
 - **Multi-printer support** -- automatically detects all connected DYMO printers; select specific printer when multiple are available
+- **Per-printer settings** -- the tape size and colors loaded in each printer are remembered across visits, so you don't re-pick them every time
 - **Virtual printers** -- configure virtual printers that save labels as PNG images, JSON data, or both (great for testing, archiving, and development)
 - **Batch print** -- print multiple labels with variable content using `{{varname}}` placeholders, with a table to fill in values per row, configurable copies and pause time, SSE progress streaming, and cancellation support
 - **Cut mark** -- optional dotted column painted into the trailing margin between batch labels so you can tear/cut between them; uses the existing inter-label gap, no extra tape
diff --git a/client/src/App.tsx b/client/src/App.tsx
index 8f11008..f7c167c 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -21,7 +21,10 @@ export default function App() {
         setAvailablePrinters(printers);
       } catch (error) {
         console.error("Failed to load printers:", error);
-        // Silently fail - UI will work without printer list
+        // Mark the fetch as settled (with no printers) so the per-printer
+        // settings gate lifts — otherwise the persisted controls would stay
+        // disabled forever when /api/printers is unreachable.
+        setAvailablePrinters([]);
       }
     };
     loadPrinters();
diff --git a/client/src/components/SettingsBar.test.tsx b/client/src/components/SettingsBar.test.tsx
index 808119b..13b831e 100644
--- a/client/src/components/SettingsBar.test.tsx
+++ b/client/src/components/SettingsBar.test.tsx
@@ -15,9 +15,13 @@ vi.mock("../lib/api", () => ({
   }),
   powerOn: vi.fn(),
   powerOff: vi.fn(),
+  // usePrinterSettings runs inside SettingsBar.
+  fetchPrinterSettings: vi.fn().mockResolvedValue({}),
+  savePrinterSettings: vi.fn().mockResolvedValue(undefined),
 }));
 
 import { SettingsBar } from "./SettingsBar";
+import { fetchPrinterSettings, savePrinterSettings } from "../lib/api";
 import { useLabelStore } from "../state/useLabelStore";
 import type { PrinterInfo } from "../types/label";
 
@@ -31,9 +35,12 @@ afterEach(() => {
 });
 
 beforeEach(() => {
-  // Reset store to defaults
+  vi.clearAllMocks();
+  // Reset store to defaults. availablePrintersLoaded: true so the persisted
+  // controls aren't gated off in tests that don't exercise the loading gate.
   useLabelStore.setState({
     availablePrinters: [],
+    availablePrintersLoaded: true,
     settings: {
       tapeSizeMm: 12,
       marginPx: 56,
@@ -121,6 +128,135 @@ describe("SettingsBar printer selector", () => {
   });
 });
 
+describe("SettingsBar per-printer settings persistence", () => {
+  it("applies saved settings when a printer is selected", async () => {
+    vi.mocked(fetchPrinterSettings).mockResolvedValueOnce({ tapeSizeMm: 6 });
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: { ...useLabelStore.getState().settings, printerId: "usb:1" },
+    });
+    render(<SettingsBar />);
+
+    await waitFor(() => {
+      expect(useLabelStore.getState().settings.tapeSizeMm).toBe(6);
+    });
+    expect(fetchPrinterSettings).toHaveBeenCalledWith("usb:1");
+  });
+
+  it("resets persisted fields to defaults for an unconfigured printer", async () => {
+    // Regression: switching to a printer with no saved settings must reset
+    // tape/colors to defaults, not inherit the previous printer's values.
+    vi.mocked(fetchPrinterSettings).mockResolvedValueOnce({});
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: {
+        ...useLabelStore.getState().settings,
+        printerId: "usb:1",
+        tapeSizeMm: 19,
+        foregroundColor: "white",
+        backgroundColor: "blue",
+      },
+    });
+    render(<SettingsBar />);
+
+    await waitFor(() => {
+      const s = useLabelStore.getState().settings;
+      expect(s.tapeSizeMm).toBe(12);
+      expect(s.foregroundColor).toBe("black");
+      expect(s.backgroundColor).toBe("white");
+    });
+  });
+
+  it("persists the full subset when the tape size changes", async () => {
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: { ...useLabelStore.getState().settings, printerId: "usb:1" },
+    });
+    render(<SettingsBar />);
+    screen.getByText("Settings").click();
+
+    const tapeSelect = screen.getByDisplayValue("12");
+    // The control is gated until the printer's settings resolve.
+    await waitFor(() => expect(tapeSelect).not.toBeDisabled());
+    await userEvent.selectOptions(tapeSelect, "19");
+
+    expect(savePrinterSettings).toHaveBeenCalledWith("usb:1", {
+      tapeSizeMm: 19,
+      foregroundColor: "black",
+      backgroundColor: "white",
+    });
+  });
+
+  it("disables persisted controls until the printer list loads", () => {
+    useLabelStore.setState({ availablePrinters: [], availablePrintersLoaded: false });
+    render(<SettingsBar />);
+    screen.getByText("Settings").click();
+    expect(screen.getByDisplayValue("12")).toBeDisabled();
+  });
+
+  it("disables then re-enables persisted controls around the settings fetch", async () => {
+    // A never-resolving fetch keeps the control gated.
+    let resolve!: (v: Record<string, never>) => void;
+    vi.mocked(fetchPrinterSettings).mockReturnValueOnce(
+      new Promise((r) => {
+        resolve = r;
+      }),
+    );
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: { ...useLabelStore.getState().settings, printerId: "usb:1" },
+    });
+    render(<SettingsBar />);
+    screen.getByText("Settings").click();
+
+    const tapeSelect = screen.getByDisplayValue("12");
+    await waitFor(() => expect(tapeSelect).toBeDisabled());
+    resolve({});
+    await waitFor(() => expect(tapeSelect).not.toBeDisabled());
+  });
+
+  it("re-enables controls (graceful unlock) when the settings fetch errors", async () => {
+    vi.mocked(fetchPrinterSettings).mockRejectedValueOnce(new Error("Pi down"));
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: { ...useLabelStore.getState().settings, printerId: "usb:1" },
+    });
+    render(<SettingsBar />);
+    screen.getByText("Settings").click();
+
+    const tapeSelect = screen.getByDisplayValue("12");
+    await waitFor(() => expect(tapeSelect).not.toBeDisabled());
+  });
+
+  it("uses the single connected printer even on Auto-select", async () => {
+    useLabelStore.setState({
+      availablePrinters: [twoPrinters[0]!],
+      settings: { ...useLabelStore.getState().settings, printerId: undefined },
+    });
+    render(<SettingsBar />);
+
+    await waitFor(() => {
+      expect(fetchPrinterSettings).toHaveBeenCalledWith("usb:1");
+    });
+  });
+
+  it("does not persist on Auto-select with multiple printers", async () => {
+    useLabelStore.setState({
+      availablePrinters: twoPrinters,
+      settings: { ...useLabelStore.getState().settings, printerId: undefined },
+    });
+    render(<SettingsBar />);
+    screen.getByText("Settings").click();
+
+    const tapeSelect = screen.getByDisplayValue("12");
+    await userEvent.selectOptions(tapeSelect, "19");
+
+    expect(savePrinterSettings).not.toHaveBeenCalled();
+    // Ambiguous which printer the server picks, so we don't read either.
+    expect(fetchPrinterSettings).not.toHaveBeenCalled();
+  });
+});
+
 describe("SettingsBar power toggle visibility", () => {
   it("shows the power toggle when a real USB printer is selected", async () => {
     useLabelStore.setState({
diff --git a/client/src/components/SettingsBar.tsx b/client/src/components/SettingsBar.tsx
index fb88a46..d5b786d 100644
--- a/client/src/components/SettingsBar.tsx
+++ b/client/src/components/SettingsBar.tsx
@@ -1,4 +1,5 @@
 import { useLabelStore } from "../state/useLabelStore";
+import { usePrinterSettings } from "../state/usePrinterSettings";
 import { TAPE_SIZES, LABEL_COLORS } from "../lib/constants";
 import { fetchPrinters } from "../lib/api";
 import type { TapeSize, Alignment, LabelColor } from "../types/label";
@@ -12,6 +13,12 @@ export function SettingsBar() {
   const setAvailablePrinters = useLabelStore((s) => s.setAvailablePrinters);
   const [isRefreshing, setIsRefreshing] = useState(false);
 
+  // Per-printer settings persistence: applies saved tape/color for the
+  // selected printer, and `persist` saves user changes to those. `loading`
+  // is true until those settings resolve — we disable the persisted controls
+  // until then so a late-arriving fetch can't clobber an edit.
+  const { persist, loading: settingsLoading } = usePrinterSettings();
+
   const handleRefreshPrinters = async () => {
     setIsRefreshing(true);
     try {
@@ -24,13 +31,10 @@ export function SettingsBar() {
     }
   };
 
-  // Only show printer selector if multiple printers are detected
-  // TODO: Future improvements for multi-printer UI:
-  // - Show printer status indicators (online/offline)
-  // - Display tape type/color/width for each printer
-  // - Allow users to set friendly aliases for printers
-  // - Remember last selected printer per user
-  // - Support printer-specific preset configurations
+  // Only show printer selector if multiple printers are detected.
+  // Tape size + colors now persist per printer; the rest of
+  // the multi-printer UI cluster (status indicators, capability-aware tape
+  // display, aliases, presets) is tracked in #38.
   const showPrinterSelector = availablePrinters.length > 1;
 
   // The selection shown in the dropdown. Fall back to the first printer
@@ -84,13 +88,22 @@ export function SettingsBar() {
 
       {!selectedIsVirtual && <PowerToggle />}
 
+      {settingsLoading && (
+        <span className="text-xs text-gray-500 italic">
+          Loading printer settings…
+        </span>
+      )}
+
       <Field label="Tape (mm)">
         <select
           className="input w-20"
           value={settings.tapeSizeMm}
-          onChange={(e) =>
-            update({ tapeSizeMm: Number(e.target.value) as TapeSize })
-          }
+          disabled={settingsLoading}
+          onChange={(e) => {
+            const tapeSizeMm = Number(e.target.value) as TapeSize;
+            update({ tapeSizeMm });
+            persist({ tapeSizeMm });
+          }}
         >
           {TAPE_SIZES.map((s) => (
             <option key={s} value={s}>
@@ -138,9 +151,12 @@ export function SettingsBar() {
         <select
           className="input w-24"
           value={settings.foregroundColor}
-          onChange={(e) =>
-            update({ foregroundColor: e.target.value as LabelColor })
-          }
+          disabled={settingsLoading}
+          onChange={(e) => {
+            const foregroundColor = e.target.value as LabelColor;
+            update({ foregroundColor });
+            persist({ foregroundColor });
+          }}
         >
           {LABEL_COLORS.map((c) => (
             <option key={c} value={c}>
@@ -154,9 +170,12 @@ export function SettingsBar() {
         <select
           className="input w-24"
           value={settings.backgroundColor}
-          onChange={(e) =>
-            update({ backgroundColor: e.target.value as LabelColor })
-          }
+          disabled={settingsLoading}
+          onChange={(e) => {
+            const backgroundColor = e.target.value as LabelColor;
+            update({ backgroundColor });
+            persist({ backgroundColor });
+          }}
         >
           {LABEL_COLORS.map((c) => (
             <option key={c} value={c}>
diff --git a/client/src/lib/api.test.ts b/client/src/lib/api.test.ts
index a7c5094..04b9150 100644
--- a/client/src/lib/api.test.ts
+++ b/client/src/lib/api.test.ts
@@ -7,6 +7,8 @@ import {
   printLabel,
   fetchServerPreview,
   uploadImage,
+  fetchPrinterSettings,
+  savePrinterSettings,
 } from "./api";
 import type { LabelWidget, LabelSettings } from "../types/label";
 
@@ -255,3 +257,64 @@ describe("uploadImage", () => {
     await expect(uploadImage(file)).rejects.toThrow("No file provided");
   });
 });
+
+describe("fetchPrinterSettings", () => {
+  it("GETs the URL-encoded printer id and returns the settings", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ settings: { tapeSizeMm: 19 } }),
+    });
+
+    const result = await fetchPrinterSettings("Bus 001 Device 005: ID 0922:1234");
+
+    expect(result).toEqual({ tapeSizeMm: 19 });
+    expect(mockFetch).toHaveBeenCalledWith(
+      "/api/printers/Bus%20001%20Device%20005%3A%20ID%200922%3A1234/settings",
+    );
+  });
+
+  it("returns {} when the server reports no saved settings", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ settings: {} }),
+    });
+    expect(await fetchPrinterSettings("usb:1")).toEqual({});
+  });
+
+  it("throws on a non-ok response", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false });
+    await expect(fetchPrinterSettings("usb:1")).rejects.toThrow();
+  });
+});
+
+describe("savePrinterSettings", () => {
+  it("PUTs the settings as JSON to the encoded id", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({}) });
+
+    await savePrinterSettings("virtual:Office", {
+      tapeSizeMm: 12,
+      foregroundColor: "black",
+      backgroundColor: "white",
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "/api/printers/virtual%3AOffice/settings",
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          tapeSizeMm: 12,
+          foregroundColor: "black",
+          backgroundColor: "white",
+        }),
+      },
+    );
+  });
+
+  it("throws on a non-ok response", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false });
+    await expect(
+      savePrinterSettings("usb:1", { tapeSizeMm: 12 }),
+    ).rejects.toThrow();
+  });
+});
diff --git a/client/src/lib/api.ts b/client/src/lib/api.ts
index f220c99..1be70c0 100644
--- a/client/src/lib/api.ts
+++ b/client/src/lib/api.ts
@@ -3,6 +3,7 @@ import type {
   LabelSettings,
   PrinterInfo,
   PowerStatus,
+  PersistedPrinterSettings,
 } from "../types/label";
 
 interface PrintResponse {
@@ -189,3 +190,32 @@ export async function powerOff(): Promise<PowerStatus> {
   const res = await fetch("/api/power/off", { method: "POST" });
   return _readPowerResponse(res);
 }
+
+// Per-printer label settings: the long-lived "what tape/colors
+// are loaded" subset, persisted server-side keyed by printer id. Printer
+// ids contain spaces and colons, so encode the whole segment.
+export async function fetchPrinterSettings(
+  printerId: string,
+): Promise<PersistedPrinterSettings> {
+  const res = await fetch(
+    `/api/printers/${encodeURIComponent(printerId)}/settings`,
+  );
+  if (!res.ok) throw new Error("Failed to fetch printer settings");
+  const data = (await res.json()) as { settings?: PersistedPrinterSettings };
+  return data.settings ?? {};
+}
+
+export async function savePrinterSettings(
+  printerId: string,
+  settings: PersistedPrinterSettings,
+): Promise<void> {
+  const res = await fetch(
+    `/api/printers/${encodeURIComponent(printerId)}/settings`,
+    {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(settings),
+    },
+  );
+  if (!res.ok) throw new Error("Failed to save printer settings");
+}
diff --git a/client/src/lib/labelFile.test.ts b/client/src/lib/labelFile.test.ts
new file mode 100644
index 0000000..c81d3c5
--- /dev/null
+++ b/client/src/lib/labelFile.test.ts
@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import { exportLabel } from "./labelFile";
+import type { LabelWidget, LabelSettings } from "../types/label";
+
+const settings: LabelSettings = {
+  tapeSizeMm: 12,
+  marginPx: 56,
+  minLengthMm: 0,
+  justify: "center",
+  foregroundColor: "black",
+  backgroundColor: "white",
+  showMargins: false,
+  cutMark: false,
+  printerId: "serial:ABC123",
+};
+
+describe("exportLabel", () => {
+  it("omits printerId from the exported settings", async () => {
+    // printerId is environment-specific (local serial / virtual id), not
+    // portable label content, and shouldn't leak into a shared file.
+    const widgets: LabelWidget[] = [{ id: "1", type: "qr", content: "x" }];
+    const json = JSON.parse(await exportLabel(widgets, settings));
+    expect("printerId" in json.settings).toBe(false);
+    expect(json.settings.tapeSizeMm).toBe(12);
+  });
+});
diff --git a/client/src/lib/labelFile.ts b/client/src/lib/labelFile.ts
index dfc33b3..aadd7ac 100644
--- a/client/src/lib/labelFile.ts
+++ b/client/src/lib/labelFile.ts
@@ -68,7 +68,14 @@ export async function exportLabel(
     }
   }
 
-  const data: LabelFile = { version: 2, settings, widgets: exportWidgets };
+  // Omit printerId: it's environment-specific (a USB serial / local virtual
+  // id), not portable label content, and would otherwise leak the local
+  // printer identity into shared files. JSON.stringify drops the undefined.
+  const data: LabelFile = {
+    version: 2,
+    settings: { ...settings, printerId: undefined },
+    widgets: exportWidgets,
+  };
 
   // Export the batch block whenever the user has touched anything in the
   // panel (rows with values, or non-default copies/pause). Batch mode is
diff --git a/client/src/lib/printerSettings.test.ts b/client/src/lib/printerSettings.test.ts
new file mode 100644
index 0000000..e1479e2
--- /dev/null
+++ b/client/src/lib/printerSettings.test.ts
@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { effectivePrinterId, pickPersisted } from "./printerSettings";
+import type { LabelSettings, PrinterInfo } from "../types/label";
+
+const printer = (id: string): PrinterInfo => ({
+  id,
+  name: id,
+  vendorProductId: "0922:1002",
+});
+
+describe("effectivePrinterId", () => {
+  it("returns the explicit selection when set", () => {
+    expect(effectivePrinterId("usb:2", [printer("usb:1"), printer("usb:2")])).toBe(
+      "usb:2",
+    );
+  });
+
+  it("falls back to the sole printer on Auto-select", () => {
+    expect(effectivePrinterId(undefined, [printer("usb:1")])).toBe("usb:1");
+  });
+
+  it("is undefined on Auto-select with multiple printers", () => {
+    expect(
+      effectivePrinterId(undefined, [printer("usb:1"), printer("usb:2")]),
+    ).toBeUndefined();
+  });
+
+  it("is undefined on Auto-select with no printers", () => {
+    expect(effectivePrinterId(undefined, [])).toBeUndefined();
+  });
+});
+
+describe("pickPersisted", () => {
+  it("keeps only the per-printer-persisted keys", () => {
+    const settings: LabelSettings = {
+      tapeSizeMm: 19,
+      marginPx: 56,
+      minLengthMm: 0,
+      justify: "center",
+      foregroundColor: "white",
+      backgroundColor: "blue",
+      showMargins: true,
+      cutMark: true,
+      printerId: "usb:1",
+    };
+    expect(pickPersisted(settings)).toEqual({
+      tapeSizeMm: 19,
+      foregroundColor: "white",
+      backgroundColor: "blue",
+    });
+  });
+});
diff --git a/client/src/lib/printerSettings.ts b/client/src/lib/printerSettings.ts
new file mode 100644
index 0000000..8f8066c
--- /dev/null
+++ b/client/src/lib/printerSettings.ts
@@ -0,0 +1,40 @@
+import type {
+  LabelSettings,
+  PersistedPrinterSettings,
+  PrinterInfo,
+} from "../types/label";
+
+// The settings keys persisted per printer. Single source of truth for
+// pickPersisted; the server validates the same set (printer_settings.py).
+export const PERSISTED_PRINTER_KEYS = [
+  "tapeSizeMm",
+  "foregroundColor",
+  "backgroundColor",
+] as const;
+
+/**
+ * Which printer to persist settings against.
+ *
+ * - An explicit selection always wins.
+ * - With no selection ("Auto-select") but exactly one printer connected,
+ *   that printer is unambiguous, so kiosk/single-printer setups still get
+ *   persistence even though the UI hides the selector.
+ * - With multiple printers and no selection we can't know which one the
+ *   server will auto-pick, so we persist nothing (undefined).
+ */
+export function effectivePrinterId(
+  selectedId: string | undefined,
+  printers: PrinterInfo[],
+): string | undefined {
+  if (selectedId) return selectedId;
+  if (printers.length === 1) return printers[0]!.id;
+  return undefined;
+}
+
+/** Extract just the per-printer-persisted subset from full label settings.
+ *  Derived from PERSISTED_PRINTER_KEYS so it can't drift from that list. */
+export function pickPersisted(settings: LabelSettings): PersistedPrinterSettings {
+  return Object.fromEntries(
+    PERSISTED_PRINTER_KEYS.map((key) => [key, settings[key]]),
+  ) as PersistedPrinterSettings;
+}
diff --git a/client/src/state/useLabelStore.test.ts b/client/src/state/useLabelStore.test.ts
index 853e884..f4b3553 100644
--- a/client/src/state/useLabelStore.test.ts
+++ b/client/src/state/useLabelStore.test.ts
@@ -133,6 +133,14 @@ describe("Printers", () => {
     expect(useLabelStore.getState().availablePrinters).toEqual(printers);
   });
 
+  it("setAvailablePrinters marks the list as loaded", () => {
+    // The per-printer settings gate keys off this; App also calls
+    // setAvailablePrinters([]) on fetch error so the gate still lifts.
+    useLabelStore.setState({ availablePrintersLoaded: false });
+    useLabelStore.getState().setAvailablePrinters([]);
+    expect(useLabelStore.getState().availablePrintersLoaded).toBe(true);
+  });
+
   it("defaults the selection to the first printer when none is chosen", () => {
     useLabelStore.getState().setAvailablePrinters([
       { id: "usb:1", name: "A", vendorProductId: "0922:1002" },
@@ -192,6 +200,30 @@ describe("Load", () => {
     expect(useLabelStore.getState().widgets).toEqual(widgets);
     expect(useLabelStore.getState().settings).toEqual(settings);
   });
+
+  it("loadLabel keeps the current printer selection", () => {
+    // Importing a label loads its design content but must not reassign the
+    // printer you're on (its printerId is stripped on export anyway).
+    useLabelStore.setState({
+      settings: { ...useLabelStore.getState().settings, printerId: "serial:ME" },
+    });
+    const settings: LabelSettings = {
+      tapeSizeMm: 6,
+      marginPx: 20,
+      minLengthMm: 10,
+      justify: "left",
+      foregroundColor: "blue",
+      backgroundColor: "yellow",
+      showMargins: true,
+      cutMark: false,
+      printerId: "serial:OTHER",
+    };
+
+    useLabelStore.getState().loadLabel([], settings);
+
+    expect(useLabelStore.getState().settings.printerId).toBe("serial:ME");
+    expect(useLabelStore.getState().settings.tapeSizeMm).toBe(6);
+  });
 });
 
 describe("Variable rename in batch rows", () => {
diff --git a/client/src/state/useLabelStore.ts b/client/src/state/useLabelStore.ts
index 9f4ebd0..60bfb54 100644
--- a/client/src/state/useLabelStore.ts
+++ b/client/src/state/useLabelStore.ts
@@ -30,6 +30,10 @@ interface LabelStore {
   widgets: LabelWidget[];
   settings: LabelSettings;
   availablePrinters: PrinterInfo[];
+  // Whether the initial /api/printers fetch has settled. Distinguishes
+  // "not fetched yet" from "fetched, none found" so per-printer settings
+  // can hold edits until the effective printer's settings are known.
+  availablePrintersLoaded: boolean;
   batch: BatchState;
 
   addTextWidget: () => string;
@@ -52,6 +56,20 @@ interface LabelStore {
   ) => void;
 }
 
+// Default label settings — single source of truth for the store's initial
+// state and for resetting per-printer-persisted fields when a selected
+// printer has no saved settings (so it doesn't inherit the previous one's).
+export const DEFAULT_SETTINGS: LabelSettings = {
+  tapeSizeMm: 12,
+  marginPx: DEFAULT_MARGIN_PX,
+  minLengthMm: 0,
+  justify: "center",
+  foregroundColor: "black",
+  backgroundColor: "white",
+  showMargins: false,
+  cutMark: false,
+};
+
 export const useLabelStore = create<LabelStore>((set) => ({
   widgets: [
     {
@@ -65,18 +83,10 @@ export const useLabelStore = create<LabelStore>((set) => ({
     } satisfies TextWidget,
   ],
 
-  settings: {
-    tapeSizeMm: 12,
-    marginPx: DEFAULT_MARGIN_PX,
-    minLengthMm: 0,
-    justify: "center",
-    foregroundColor: "black",
-    backgroundColor: "white",
-    showMargins: false,
-    cutMark: false,
-  },
+  settings: { ...DEFAULT_SETTINGS },
 
   availablePrinters: [],
+  availablePrintersLoaded: false,
 
   batch: defaultBatch(),
 
@@ -226,16 +236,21 @@ export const useLabelStore = create<LabelStore>((set) => ({
     set((s) => {
       // Default the selection to a concrete printer — the first in the list,
       // which is the first real USB printer when one is present (virtual
-      // printers are listed after). This way a selected printer (and, with
-      // per-printer settings, its saved tape/colors) is active on load
-      // instead of an "Auto-select" placeholder. Keep the current selection
-      // if it's still connected; otherwise fall back to the first printer
-      // (or undefined when none are connected).
+      // printers are listed after). This way a selected printer (and its
+      // saved tape/colors) is active on load instead of an "Auto-select"
+      // placeholder. Keep the current selection if it's still connected;
+      // otherwise fall back to the first printer (or undefined when none are
+      // connected). availablePrintersLoaded gates the per-printer settings
+      // load until this first fetch has settled.
       const stillPresent =
         s.settings.printerId != null &&
         printers.some((p) => p.id === s.settings.printerId);
       const printerId = stillPresent ? s.settings.printerId : printers[0]?.id;
-      return { availablePrinters: printers, settings: { ...s.settings, printerId } };
+      return {
+        availablePrinters: printers,
+        availablePrintersLoaded: true,
+        settings: { ...s.settings, printerId },
+      };
     }),
 
   updateBatch: (patch) =>
@@ -276,5 +291,12 @@ export const useLabelStore = create<LabelStore>((set) => ({
     }),
 
   loadLabel: (widgets, settings, batch) =>
-    set({ widgets, settings, batch: batch ?? defaultBatch() }),
+    // Keep the currently-selected printer; a label file describes design
+    // content (tape/colors/widgets), not which printer you're on. Its
+    // printerId is stripped on export and ignored here regardless.
+    set((s) => ({
+      widgets,
+      settings: { ...settings, printerId: s.settings.printerId },
+      batch: batch ?? defaultBatch(),
+    })),
 }));
diff --git a/client/src/state/usePrinterSettings.ts b/client/src/state/usePrinterSettings.ts
new file mode 100644
index 0000000..f2def52
--- /dev/null
+++ b/client/src/state/usePrinterSettings.ts
@@ -0,0 +1,88 @@
+import { useEffect, useState } from "react";
+import { useLabelStore, DEFAULT_SETTINGS } from "./useLabelStore";
+import { fetchPrinterSettings, savePrinterSettings } from "../lib/api";
+import {
+  effectivePrinterId,
+  pickPersisted,
+} from "../lib/printerSettings";
+import type { PersistedPrinterSettings } from "../types/label";
+
+/**
+ * Wires per-printer settings persistence in two directions:
+ *
+ * - **Apply on select:** whenever the effective printer changes, fetch its
+ *   saved subset and apply it to the store.
+ * - **Save on change:** `persist(patch)` writes the full current subset for
+ *   the effective printer. Callers invoke it from user-driven onChange only,
+ *   so applying-from-server never loops back into a save.
+ *
+ * Each save sends the whole subset (not just the changed field) so the
+ * server's wholesale-per-printer write never drops a previously saved value.
+ *
+ * Returns `loading`: true from app start until the effective printer's
+ * settings have resolved (or there is no effective printer). Callers disable
+ * the persisted controls while it's true, which closes two races: a slow
+ * apply-fetch reverting a concurrent edit, and edits made before the printer
+ * list resolves being lost. On a fetch error it clears (graceful unlock —
+ * keep defaults, don't persist) so the UI never locks permanently.
+ */
+export function usePrinterSettings(): {
+  persist: (patch: PersistedPrinterSettings) => void;
+  loading: boolean;
+} {
+  const settings = useLabelStore((s) => s.settings);
+  const availablePrinters = useLabelStore((s) => s.availablePrinters);
+  const availablePrintersLoaded = useLabelStore((s) => s.availablePrintersLoaded);
+  const updateSettings = useLabelStore((s) => s.updateSettings);
+
+  const printerId = effectivePrinterId(settings.printerId, availablePrinters);
+  const [settingsLoading, setSettingsLoading] = useState(false);
+
+  useEffect(() => {
+    if (!printerId) {
+      setSettingsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setSettingsLoading(true);
+    fetchPrinterSettings(printerId)
+      .then((saved) => {
+        // Always set the persisted fields: saved values where present, else
+        // defaults. A printer with no saved settings must reset to defaults,
+        // not inherit the previously-selected printer's tape/colors.
+        if (!cancelled) {
+          updateSettings({ ...pickPersisted(DEFAULT_SETTINGS), ...saved });
+        }
+      })
+      .catch((error) => {
+        if (!cancelled) console.error("Failed to load printer settings:", error);
+      })
+      .finally(() => {
+        if (!cancelled) setSettingsLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [printerId, updateSettings]);
+
+  // Block edits to persisted fields until we know what they should be:
+  // before the printer list loads, and while the chosen printer's settings
+  // are being fetched.
+  const loading =
+    !availablePrintersLoaded || (printerId !== undefined && settingsLoading);
+
+  const persist = (patch: PersistedPrinterSettings) => {
+    if (!printerId) return;
+    // Read the live store rather than the `settings` captured in this render:
+    // consecutive user edits can fire before a re-render, and the full subset
+    // we send must reflect the latest values, not stale ones.
+    const current = useLabelStore.getState().settings;
+    savePrinterSettings(printerId, { ...pickPersisted(current), ...patch }).catch(
+      (error) => {
+        console.error("Failed to save printer settings:", error);
+      },
+    );
+  };
+
+  return { persist, loading };
+}
diff --git a/client/src/types/label.ts b/client/src/types/label.ts
index a6b7b9c..3a18e16 100644
--- a/client/src/types/label.ts
+++ b/client/src/types/label.ts
@@ -107,3 +107,11 @@ export interface LabelSettings {
   cutMark: boolean;
   printerId?: string; // Optional printer ID for multi-printer setups
 }
+
+// The subset of LabelSettings persisted per printer: the
+// physical "what tape/colors are loaded" properties. Partial because a
+// printer may only have some of them saved. Kept narrow on purpose —
+// margins/justify/cutMark are label preferences, not printer state.
+export type PersistedPrinterSettings = Partial<
+  Pick<LabelSettings, "tapeSizeMm" | "foregroundColor" | "backgroundColor">
+>;
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 7dbafe6..8c66a64 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -143,6 +143,36 @@ The backend supports two types of printers:
 
 **Output Filename Format (virtual printers):** `label_YYYYMMDD_HHMMSS_uuid.png`
 
+### Persistent State (`state_store.py`)
+
+A single JSON file (`LABELLE_STATE_FILE`, default `/app/output/.labelle/state.json`,
+inside the already-mounted output volume) holds the small bits of state that
+must survive container restarts. `state_store.py` owns it and is the only writer:
+every write is an atomic read-modify-write of the whole document under a shared
+lock, so independent features can each persist their slice without clobbering
+the others.
+
+Current slices:
+- **USB power** (`usb_power.py`): top-level `hub`/`port` — the last known
+  controllable port, so power-on still works after the device has been powered
+  off and dropped off the USB tree.
+- **Per-printer settings** (`printer_settings.py`): a `printers` map keyed by
+  `PrinterInfo.id`, storing the long-lived tape size + foreground/background
+  colors loaded in each printer. Validated server-side; the client
+  applies a printer's saved subset on selection and writes back on change
+  (`usePrinterSettings`). The "effective printer" is the explicit selection,
+  or the sole printer when on Auto-select — so single-printer kiosks persist
+  too. v2 follow-ups (aliases, presets, remember-last) are expected to extend
+  this same per-printer map.
+
+  The persisted controls (tape/colors) are **disabled until the effective
+  printer's settings have resolved** — before the printer list loads and while
+  the fetch is in flight — so a late-arriving fetch can't revert an edit and
+  pre-load edits aren't lost; a fetch error unlocks them (keep defaults). And
+  `printerId` is **stripped from exported label files** (it's a local
+  serial/virtual id, not portable content); importing a label keeps the
+  printer you're currently on.
+
 ### Request Flow
 
 ```
@@ -347,11 +377,13 @@ Uncomment the output volume mount in `compose.yaml` to access saved labels on th
 TODOs documented in code comments:
 
 **Backend (app.py, label_builder.py):**
-- Per-printer settings persistence (tape size, margins, color)
 - Printer status/health checks (online/offline, tape level)
 - Printer list caching to reduce USB scans
 - Printer capability detection (supported tape sizes, colors)
 
+(Per-printer tape-size/color persistence shipped in v1.8.0 — see "Per-printer
+settings" below. The remaining three are tracked in issue #38.)
+
 **Frontend (SettingsBar.tsx):**
 - Printer status indicators in UI
 - Display tape type/color/width for each printer
diff --git a/package.json b/package.json
index d486818..3cfff0d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "labelle-web",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "private": true,
   "description": "Web interface for labelle DYMO label printers",
   "scripts": {
diff --git a/server/app.py b/server/app.py
index 285adaa..b66a234 100644
--- a/server/app.py
+++ b/server/app.py
@@ -47,6 +47,7 @@
 from werkzeug.utils import secure_filename
 
 import power_save
+import printer_settings
 import usb_power
 from label_builder import paint_cut_mark_in_trailing_margin, preview_label, render_payload
 from printer_service import list_printers, print_bitmap, print_label
@@ -210,6 +211,28 @@ def api_printers():
     return jsonify(printers=list_printers())
 
 
+# Per-printer label settings. Printer ids contain spaces and
+# colons (e.g. "Bus 001 Device 005: ID 0922:1234", "virtual:Office"), so
+# the client URL-encodes them and we take the whole segment via <path:>.
+@app.route("/api/printers/<path:printer_id>/settings", methods=["GET"])
+def api_get_printer_settings(printer_id):
+    return jsonify(settings=printer_settings.get_settings(printer_id))
+
+
+@app.route("/api/printers/<path:printer_id>/settings", methods=["PUT"])
+def api_put_printer_settings(printer_id):
+    body = request.get_json(silent=True)
+    if not isinstance(body, dict):
+        # Reject malformed/non-JSON bodies rather than letting them coerce to
+        # {} and silently wipe the printer's saved settings.
+        return jsonify(status="error", message="Request body must be a JSON object"), 400
+    try:
+        saved = printer_settings.save_settings(printer_id, body)
+    except ValueError as e:
+        return jsonify(status="error", message=str(e)), 400
+    return jsonify(status="success", settings=saved)
+
+
 def _printer_port_or_404():
     port = usb_power.find_or_recall_printer_port()
     if port is None:
diff --git a/server/printer_settings.py b/server/printer_settings.py
new file mode 100644
index 0000000..acb1292
--- /dev/null
+++ b/server/printer_settings.py
@@ -0,0 +1,115 @@
+"""Per-printer label settings persistence (issue #20).
+
+The physical tape loaded in a printer — its width and colors — is a
+long-lived property of *that printer*, not a per-label choice. We save
+the subset the user picks, keyed by printer id, so it isn't re-selected
+on every visit (especially painful in kiosk / shared-tablet setups).
+
+Keyed by `PrinterInfo.id`: the USB id string for real printers
+(`Bus 001 Device 005: ID 0922:1234`) or `virtual:<name>` for virtual
+ones — both stable across reboots. State rides in the shared state file
+under a "printers" namespace alongside the USB power cache.
+
+Out of scope: batch row data (lives in the label JSON),
+and recovering settings for a disconnected printer (we just keep the
+entry and restore it when the printer reappears).
+
+v2 follow-ups (aliases, remember-last, presets) are expected to extend
+this same per-printer store — keep the shape easy to grow.
+"""
+
+import state_store
+
+# The subset we persist, with their allowed values. Deliberately the
+# "physical printer state" minimum — margin/justify/cutMark
+# are arguably label preferences and are left out until that's decided.
+_VALID_TAPE_SIZES = {6, 9, 12, 19}
+_VALID_COLORS = {"white", "black", "yellow", "blue", "red", "green"}
+
+# Allowed values per persisted key. Single source of truth for both
+# _validate (raise on write) and _sanitize (drop on read).
+_ALLOWED_VALUES = {
+    "tapeSizeMm": _VALID_TAPE_SIZES,
+    "foregroundColor": _VALID_COLORS,
+    "backgroundColor": _VALID_COLORS,
+}
+
+_PERSISTED_KEYS = tuple(_ALLOWED_VALUES)
+
+_PRINTERS_KEY = "printers"
+
+# Cap the persisted printer-id length. Real ids are short (a USB id string
+# or "serial:"/"virtual:" + name); this just stops an unauthenticated client
+# from bloating the shared state file with absurdly long keys.
+_MAX_PRINTER_ID_LEN = 256
+
+
+def _is_allowed(key: str, value) -> bool:
+    """Whether `value` is permitted for `key`. Unhashable values (a list or
+    dict from a malformed request / hand-edited file) are simply not allowed,
+    rather than raising TypeError from the set-membership check."""
+    try:
+        return value in _ALLOWED_VALUES[key]
+    except TypeError:
+        return False
+
+
+def _validate(settings: dict) -> None:
+    if not isinstance(settings, dict):
+        raise ValueError("settings must be an object")
+    unknown = set(settings) - set(_PERSISTED_KEYS)
+    if unknown:
+        raise ValueError(f"Unknown printer setting(s): {sorted(unknown)}")
+    for key, value in settings.items():
+        if not _is_allowed(key, value):
+            raise ValueError(f"Invalid {key}: {value!r}")
+
+
+def _sanitize(entry: dict) -> dict:
+    """Best-effort filter to known keys with allowed values; never raises.
+
+    Used on read so a hand-edited/corrupt state file can't serve unknown
+    keys or out-of-range values back to the client. The mirror of
+    _validate, which raises on the same conditions at write time.
+    """
+    return {
+        key: value
+        for key, value in entry.items()
+        if key in _ALLOWED_VALUES and _is_allowed(key, value)
+    }
+
+
+def get_settings(printer_id: str, path=None) -> dict:
+    """Return the saved subset for a printer, or {} if none saved.
+
+    Sanitizes on read so a corrupt/hand-edited file yields only valid
+    values, consistent with the validation enforced at write time.
+    """
+    printers = state_store.read_all(path).get(_PRINTERS_KEY)
+    if not isinstance(printers, dict):
+        return {}
+    entry = printers.get(printer_id)
+    return _sanitize(entry) if isinstance(entry, dict) else {}
+
+
+def save_settings(printer_id: str, settings: dict, path=None) -> dict:
+    """Validate and persist the subset for a printer. Returns it.
+
+    The write replaces that printer's entry wholesale (not a deep-merge);
+    the client always sends the full current subset.
+    """
+    if not isinstance(printer_id, str) or not printer_id:
+        raise ValueError("printer_id must be a non-empty string")
+    if len(printer_id) > _MAX_PRINTER_ID_LEN:
+        raise ValueError(f"printer_id too long (max {_MAX_PRINTER_ID_LEN} chars)")
+    _validate(settings)
+
+    def mutate(d: dict) -> None:
+        # A corrupt/hand-edited file may carry a non-dict "printers"; replace
+        # it rather than letting __setitem__ raise and fail the write.
+        if not isinstance(d.get(_PRINTERS_KEY), dict):
+            d[_PRINTERS_KEY] = {}
+        d[_PRINTERS_KEY][printer_id] = settings
+
+    state_store.update(mutate, path)
+    return settings
diff --git a/server/tests/test_app.py b/server/tests/test_app.py
index db1819f..cc1c64f 100644
--- a/server/tests/test_app.py
+++ b/server/tests/test_app.py
@@ -498,3 +498,81 @@ def test_returns_500_when_print_raises(self, mock_print, client):
 
         assert resp.status_code == 500
         assert "Printer on fire" in resp.get_json()["message"]
+
+
+class TestPrinterSettingsEndpoints:
+    """GET/PUT /api/printers/<id>/settings — per-printer settings."""
+
+    @pytest.fixture
+    def state_file(self, tmp_path, monkeypatch):
+        import state_store
+
+        path = tmp_path / "state.json"
+        monkeypatch.setattr(state_store, "STATE_FILE", path)
+        return path
+
+    def test_get_returns_empty_when_unsaved(self, client, state_file):
+        resp = client.get("/api/printers/virtual:Test_Printer/settings")
+        assert resp.status_code == 200
+        assert resp.get_json() == {"settings": {}}
+
+    def test_put_then_get_round_trips(self, client, state_file):
+        body = {"tapeSizeMm": 19, "foregroundColor": "white", "backgroundColor": "blue"}
+        put = client.put(
+            "/api/printers/virtual:Test_Printer/settings",
+            data=json.dumps(body),
+            content_type="application/json",
+        )
+        assert put.status_code == 200
+        assert put.get_json()["settings"] == body
+
+        got = client.get("/api/printers/virtual:Test_Printer/settings")
+        assert got.get_json() == {"settings": body}
+
+    def test_put_invalid_value_returns_400(self, client, state_file):
+        resp = client.put(
+            "/api/printers/virtual:Test_Printer/settings",
+            data=json.dumps({"tapeSizeMm": 13}),
+            content_type="application/json",
+        )
+        assert resp.status_code == 400
+        assert resp.get_json()["status"] == "error"
+
+    def test_put_unknown_key_returns_400(self, client, state_file):
+        resp = client.put(
+            "/api/printers/virtual:Test_Printer/settings",
+            data=json.dumps({"marginPx": 10}),
+            content_type="application/json",
+        )
+        assert resp.status_code == 400
+
+    def test_put_non_json_body_returns_400_without_clearing(self, client, state_file):
+        # Seed a saved value, then send a malformed PUT.
+        client.put(
+            "/api/printers/virtual:Test_Printer/settings",
+            data=json.dumps({"tapeSizeMm": 19}),
+            content_type="application/json",
+        )
+        resp = client.put(
+            "/api/printers/virtual:Test_Printer/settings",
+            data="not json",
+            content_type="text/plain",
+        )
+        assert resp.status_code == 400
+        # The previously-saved value must survive — not be wiped to {}.
+        got = client.get("/api/printers/virtual:Test_Printer/settings")
+        assert got.get_json() == {"settings": {"tapeSizeMm": 19}}
+
+    def test_ids_with_spaces_and_colons_round_trip(self, client, state_file):
+        # Real USB ids look like "Bus 001 Device 005: ID 0922:1234".
+        from urllib.parse import quote
+
+        printer_id = "Bus 001 Device 005: ID 0922:1234"
+        encoded = quote(printer_id, safe="")
+        client.put(
+            f"/api/printers/{encoded}/settings",
+            data=json.dumps({"tapeSizeMm": 6}),
+            content_type="application/json",
+        )
+        got = client.get(f"/api/printers/{encoded}/settings")
+        assert got.get_json() == {"settings": {"tapeSizeMm": 6}}
diff --git a/server/tests/test_printer_settings.py b/server/tests/test_printer_settings.py
new file mode 100644
index 0000000..82431da
--- /dev/null
+++ b/server/tests/test_printer_settings.py
@@ -0,0 +1,148 @@
+"""Tests for per-printer label settings persistence.
+
+Stores the long-lived "what tape/colors are loaded in this printer"
+subset, keyed by printer id, in the shared state file.
+"""
+
+import pytest
+
+import printer_settings
+import state_store
+import usb_power
+
+
+class TestGet:
+    def test_returns_empty_dict_when_printer_unknown(self, tmp_path):
+        p = tmp_path / "state.json"
+        assert printer_settings.get_settings("Bus 001 Device 005", p) == {}
+
+    def test_round_trips_a_saved_subset(self, tmp_path):
+        p = tmp_path / "state.json"
+        printer_settings.save_settings(
+            "virtual:Office",
+            {"tapeSizeMm": 19, "foregroundColor": "white", "backgroundColor": "blue"},
+            p,
+        )
+        assert printer_settings.get_settings("virtual:Office", p) == {
+            "tapeSizeMm": 19,
+            "foregroundColor": "white",
+            "backgroundColor": "blue",
+        }
+
+    def test_settings_are_isolated_per_printer(self, tmp_path):
+        p = tmp_path / "state.json"
+        printer_settings.save_settings("a", {"tapeSizeMm": 6}, p)
+        printer_settings.save_settings("b", {"tapeSizeMm": 19}, p)
+        assert printer_settings.get_settings("a", p) == {"tapeSizeMm": 6}
+        assert printer_settings.get_settings("b", p) == {"tapeSizeMm": 19}
+
+
+class TestCorruptState:
+    """A hand-edited or corrupt state file must not crash get/save."""
+
+    def test_get_returns_empty_when_printers_is_not_a_dict(self, tmp_path):
+        p = tmp_path / "state.json"
+        state_store.update(lambda d: d.__setitem__("printers", []), p)
+        assert printer_settings.get_settings("a", p) == {}
+
+    def test_save_replaces_non_dict_printers(self, tmp_path):
+        p = tmp_path / "state.json"
+        state_store.update(lambda d: d.__setitem__("printers", "garbage"), p)
+        printer_settings.save_settings("a", {"tapeSizeMm": 12}, p)
+        assert printer_settings.get_settings("a", p) == {"tapeSizeMm": 12}
+
+    def test_get_sanitizes_unknown_keys_and_invalid_values(self, tmp_path):
+        """A hand-edited entry must not serve junk back to the client."""
+        p = tmp_path / "state.json"
+        state_store.update(
+            lambda d: d.__setitem__(
+                "printers",
+                {"a": {"tapeSizeMm": 999, "foregroundColor": "red", "evil": "x"}},
+            ),
+            p,
+        )
+        # tapeSizeMm 999 (out of range) and the unknown key are dropped;
+        # the valid foregroundColor survives.
+        assert printer_settings.get_settings("a", p) == {"foregroundColor": "red"}
+
+    def test_get_drops_unhashable_value_without_crashing(self, tmp_path):
+        # A list value in a hand-edited file must be dropped on read, not
+        # crash the GET with TypeError from the set-membership check.
+        p = tmp_path / "state.json"
+        state_store.update(
+            lambda d: d.__setitem__(
+                "printers", {"a": {"tapeSizeMm": [12], "foregroundColor": "red"}}
+            ),
+            p,
+        )
+        assert printer_settings.get_settings("a", p) == {"foregroundColor": "red"}
+
+
+class TestSaveValidation:
+    def test_rejects_unknown_key(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("a", {"marginPx": 10}, p)
+
+    def test_rejects_invalid_tape_size(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("a", {"tapeSizeMm": 13}, p)
+
+    def test_rejects_invalid_color(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("a", {"foregroundColor": "magenta"}, p)
+
+    def test_rejects_empty_printer_id(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("", {"tapeSizeMm": 12}, p)
+
+    def test_rejects_non_dict_body(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("a", ["tapeSizeMm"], p)
+
+    def test_rejects_unhashable_value_without_crashing(self, tmp_path):
+        # An unhashable value must raise ValueError (→ 400), not TypeError.
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("a", {"tapeSizeMm": [12]}, p)
+
+    def test_rejects_non_string_or_overlong_printer_id(self, tmp_path):
+        p = tmp_path / "state.json"
+        with pytest.raises(ValueError):
+            printer_settings.save_settings(123, {"tapeSizeMm": 12}, p)
+        with pytest.raises(ValueError):
+            printer_settings.save_settings("x" * 257, {"tapeSizeMm": 12}, p)
+
+    def test_partial_subset_is_allowed(self, tmp_path):
+        """User may have only ever changed the tape size; persist just that."""
+        p = tmp_path / "state.json"
+        printer_settings.save_settings("a", {"tapeSizeMm": 9}, p)
+        assert printer_settings.get_settings("a", p) == {"tapeSizeMm": 9}
+
+    def test_save_replaces_prior_subset(self, tmp_path):
+        p = tmp_path / "state.json"
+        printer_settings.save_settings("a", {"tapeSizeMm": 9}, p)
+        printer_settings.save_settings("a", {"foregroundColor": "red"}, p)
+        # Latest write wins wholesale for that printer; not a deep-merge.
+        assert printer_settings.get_settings("a", p) == {"foregroundColor": "red"}
+
+
+class TestCoexistenceWithUsbPower:
+    def test_saving_settings_preserves_usb_power_state(self, tmp_path):
+        """The two features share one file; neither may clobber the other."""
+        p = tmp_path / "state.json"
+        usb_power._save_state("1-1", 3, p)
+        printer_settings.save_settings("a", {"tapeSizeMm": 12}, p)
+        assert usb_power._load_state(p) == ("1-1", 3)
+        assert printer_settings.get_settings("a", p) == {"tapeSizeMm": 12}
+
+    def test_usb_power_save_preserves_printer_settings(self, tmp_path):
+        p = tmp_path / "state.json"
+        printer_settings.save_settings("a", {"tapeSizeMm": 12}, p)
+        usb_power._save_state("2-4", 7, p)
+        assert printer_settings.get_settings("a", p) == {"tapeSizeMm": 12}
+        assert usb_power._load_state(p) == ("2-4", 7)
diff --git a/server/tests/test_smoke.py b/server/tests/test_smoke.py
index 2e87ea7..97706e6 100644
--- a/server/tests/test_smoke.py
+++ b/server/tests/test_smoke.py
@@ -16,6 +16,7 @@
     "label_builder",
     "power_save",
     "printer_service",
+    "printer_settings",
     "state_store",
     "usb_power",
     "virtual_printer",
@@ -100,6 +101,7 @@ def test_app_creates(self):
             "/api/print",
             "/api/preview",
             "/api/printers",
+            "/api/printers/<path:printer_id>/settings",
             "/api/upload-image",
             "/api/uploads/<filename>",
             "/api/health",