diff --git a/src/app/admin/inhalte/page.tsx b/src/app/admin/inhalte/page.tsx
index 37cead2..c81257b 100644
--- a/src/app/admin/inhalte/page.tsx
+++ b/src/app/admin/inhalte/page.tsx
@@ -12,6 +12,9 @@ import type { Locale } from "@/i18n/config";
 const ROWS_BY_TYPE: Record<ContentFieldDef["type"], number> = {
   text: 1,
   textarea: 3,
+  // Auswahlfelder rendern ein <select> und nutzen ROWS_BY_TYPE nicht — Wert
+  // nur vorhanden, damit dieses Record vollstaendig bleibt.
+  select: 0,
   "list-simple": 4,
   "list-titled": 5,
   "list-numbered": 6,
@@ -57,6 +60,28 @@ function FieldEditor({
     if (def.type === "video") {
       return <AdminVideoField name={def.key} label={label} initialValue={row?.valueDe ?? ""} />;
     }
+    if (def.type === "select") {
+      // Ohne gepflegten Wert ist der Vorgabewert vorausgewaehlt — genau der
+      // gilt zur Laufzeit ohnehin, die Anzeige soll das nicht anders
+      // darstellen als die Wirklichkeit.
+      const current = row?.valueDe?.trim() ? row.valueDe : def.getDefault("de");
+      return (
+        <label className="block text-sm">
+          <span className="text-ink/70">{label}</span>
+          <select
+            name={def.key}
+            defaultValue={current}
+            className="mt-1 w-full border border-ink/20 bg-background px-3 py-2 focus:outline-none focus:border-forest"
+          >
+            {(def.options ?? []).map((option) => (
+              <option key={option.value} value={option.value}>
+                {locale === "de" ? option.labelDe : option.labelEn}
+              </option>
+            ))}
+          </select>
+        </label>
+      );
+    }
     return (
       <label className="block text-sm">
         <span className="text-ink/70">{label}</span>
diff --git a/src/app/api/checkout/route.test.ts b/src/app/api/checkout/route.test.ts
index 149fe60..6f43d94 100644
--- a/src/app/api/checkout/route.test.ts
+++ b/src/app/api/checkout/route.test.ts
@@ -44,7 +44,11 @@ vi.mock("@/lib/rate-limit", () => ({
   getClientIp: vi.fn(async () => "203.0.113.7"),
 }));
 
-vi.mock("@/lib/shipping", () => ({ getShippingCostCents: vi.fn(async () => 700) }));
+const getShippingRegion = vi.fn(async () => "DE" as const);
+vi.mock("@/lib/shipping", () => ({
+  getShippingCostCents: vi.fn(async () => 700),
+  getShippingRegion: () => getShippingRegion(),
+}));
 vi.mock("@/lib/bulk-discount", () => ({ ensureBulkDiscountCode: vi.fn(async () => undefined) }));
 vi.mock("@/lib/url", () => ({ getBaseUrl: () => "https://wabenhain.test" }));
 vi.mock("@/i18n/locale", () => ({ getLocale: vi.fn(async () => "de") }));
@@ -108,6 +112,7 @@ beforeEach(() => {
   rateLimit.mockReturnValue(true);
   verifyTurnstileToken.mockResolvedValue(true);
   getProductsByIds.mockResolvedValue([honey]);
+  getShippingRegion.mockResolvedValue("DE");
   db.discountCode.findMany.mockResolvedValue([]);
   db.inventory.updateMany.mockResolvedValue({ count: 1 });
   db.order.create.mockResolvedValue(ORDER);
@@ -177,6 +182,37 @@ describe("Checkout-Route", () => {
       expect(db.order.create).not.toHaveBeenCalled();
     });
 
+    test("weist eine Lieferadresse ausserhalb des Liefergebiets ab", async () => {
+      // Die Laenderauswahl im Formular bietet nur zulaessige Laender an — das
+      // ist Bequemlichkeit, kein Schutz: dieser Endpunkt nimmt JSON entgegen
+      // und laesst sich ohne Formular aufrufen.
+      const response = await post({ ...validPayload, country: "AT" });
+
+      expect(response.status).toBe(400);
+      await expect(response.json()).resolves.toMatchObject({
+        error: expect.stringContaining("innerhalb Deutschlands"),
+      });
+      expect(db.order.create).not.toHaveBeenCalled();
+    });
+
+    test('laesst bei Liefergebiet "EU" ein anderes Mitgliedsland durch', async () => {
+      getShippingRegion.mockResolvedValue("EU" as never);
+
+      const response = await post({ ...validPayload, country: "AT" });
+
+      expect(response.status).toBe(200);
+    });
+
+    test('weist bei Liefergebiet "EU" ein Drittland trotzdem ab', async () => {
+      // Die Schweiz liegt in Europa, ist aber Zollausland.
+      getShippingRegion.mockResolvedValue("EU" as never);
+
+      const response = await post({ ...validPayload, country: "CH" });
+
+      expect(response.status).toBe(400);
+      expect(db.order.create).not.toHaveBeenCalled();
+    });
+
     test("bricht ab, wenn der Bestand waehrend des Checkouts nicht mehr reicht", async () => {
       // Das bedingte updateMany trifft keine Zeile mehr — jemand anders war
       // schneller.
diff --git a/src/app/api/checkout/route.ts b/src/app/api/checkout/route.ts
index 115099e..122ed05 100644
--- a/src/app/api/checkout/route.ts
+++ b/src/app/api/checkout/route.ts
@@ -9,7 +9,8 @@ import { getCurrentCustomer } from "@/lib/auth";
 import { rateLimit, getClientIp } from "@/lib/rate-limit";
 import { isTrustedOrigin } from "@/lib/csrf";
 import { verifyTurnstileToken } from "@/lib/turnstile";
-import { getShippingCostCents } from "@/lib/shipping";
+import { getShippingCostCents, getShippingRegion } from "@/lib/shipping";
+import { isCountryAllowed } from "@/lib/shipping-region";
 import { isDiscountCodeValid, calculateDiscountCents } from "@/lib/discount-calc";
 import { ensureBulkDiscountCode } from "@/lib/bulk-discount";
 import { releaseUnpaidOrder } from "@/lib/order-release";
@@ -177,6 +178,26 @@ export async function POST(request: Request) {
         { status: 400 }
       );
     }
+
+    // Verbindliche Pruefung des Liefergebiets. Die Laenderauswahl im Formular
+    // bietet ohnehin nur zulaessige Laender an — das ist Bequemlichkeit, kein
+    // Schutz: dieser Endpunkt nimmt JSON entgegen und laesst sich ohne
+    // Formular aufrufen. Ohne die Pruefung hier entstuende eine Bestellung
+    // mit einer Lieferadresse, fuer die weder Versandweg noch
+    // Umsatzsteuerpflicht geklaert sind — und bezahlt waere sie dann auch
+    // schon.
+    const region = await getShippingRegion();
+    if (!isCountryAllowed(region, input.country)) {
+      return NextResponse.json(
+        {
+          error:
+            region === "DE"
+              ? "Wir versenden derzeit ausschließlich innerhalb Deutschlands. Bitte gib eine Lieferadresse in Deutschland an oder wähle die Abholung."
+              : "Wir versenden derzeit ausschließlich innerhalb der Europäischen Union. Bitte gib eine Lieferadresse in der EU an oder wähle die Abholung.",
+        },
+        { status: 400 }
+      );
+    }
   }
 
   const productIds = input.items.map((item) => item.productId);
diff --git a/src/app/checkout/checkout-form.tsx b/src/app/checkout/checkout-form.tsx
index ee97725..ed28489 100644
--- a/src/app/checkout/checkout-form.tsx
+++ b/src/app/checkout/checkout-form.tsx
@@ -10,9 +10,28 @@ import { resolveShippingCostCents, type ShippingTierLike } from "@/lib/shipping-
 import { resolveBulkDiscount, type BulkDiscountTierLike } from "@/lib/bulk-discount-calc";
 import { useI18n } from "@/i18n/i18n-provider";
 import { TurnstileWidget } from "@/components/turnstile-widget";
+import { allowedCountryCodes, type ShippingRegion } from "@/lib/shipping-region";
 
 type Fulfillment = "VERSAND" | "ABHOLUNG";
 
+/**
+ * Laendername in der Sprache der Oberflaeche.
+ *
+ * Intl.DisplayNames statt 27 Laendernamen je Sprache im Woerterbuch: die
+ * Namen stehen bereits in jedem Browser und jeder Node-Laufzeit, und eine
+ * eigene Liste waere ab dem naechsten Beitritt oder der naechsten Umbenennung
+ * falsch. Faellt die Aufloesung aus, bleibt der Code stehen — unschoen, aber
+ * eindeutig, und die Bestellung geht trotzdem.
+ */
+function countryName(code: string, locale: string): string {
+  try {
+    return new Intl.DisplayNames([locale], { type: "region" }).of(code) ?? code;
+  } catch {
+    return code;
+  }
+}
+
+
 /** Hausanschrift oder DHL-Packstation — nur bei fulfillment === "VERSAND" relevant. */
 type DeliveryTarget = "ADRESSE" | "PACKSTATION";
 
@@ -42,6 +61,7 @@ export function CheckoutForm({
   bulkDiscountTiers,
   packstationSearchAvailable = false,
   turnstileSiteKey,
+  shippingRegion = "DE",
 }: {
   initialValues?: CheckoutInitialValues;
   tiers: ShippingTierLike[];
@@ -54,6 +74,13 @@ export function CheckoutForm({
   packstationSearchAvailable?: boolean;
   /** Leer, wenn Turnstile nicht konfiguriert ist — dann entfaellt das Widget. */
   turnstileSiteKey?: string;
+  /**
+   * Wohin geliefert wird (Admin-Bereich → Inhalte → Liefergebiet). Steuert
+   * die Laenderauswahl unten. Vorgabe ist der engste Zuschnitt: waere sie
+   * "EU", wuerde ein vergessenes Durchreichen der Prop stillschweigend mehr
+   * Laender anbieten, als der Shop beliefert.
+   */
+  shippingRegion?: ShippingRegion;
 }) {
   const { t, locale } = useI18n();
   const items = useCartStore((s) => s.items);
@@ -64,6 +91,9 @@ export function CheckoutForm({
   // Der Checkout schickt JSON statt eines Formulars, deshalb das Widget mit
   // Token-Rueckgabe statt eines versteckten Feldes.
   const [turnstileToken, setTurnstileToken] = useState<string | null>(null);
+  const countryCodes = allowedCountryCodes(shippingRegion);
+  // Nur eine Auswahl anbieten, wenn es etwas zu waehlen gibt.
+  const [country, setCountry] = useState(countryCodes[0]);
   const [fulfillment, setFulfillment] = useState<Fulfillment>("VERSAND");
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -157,7 +187,7 @@ export function CheckoutForm({
       city: usesPackstation
         ? selectedPackstation?.city
         : String(formData.get("city") ?? "") || undefined,
-      country: "DE",
+      country,
       packstationNumber: usesPackstation ? selectedPackstation?.number : undefined,
       postNumber: usesPackstation
         ? String(formData.get("postNumber") ?? "").trim() || undefined
@@ -327,6 +357,31 @@ export function CheckoutForm({
                   required
                 />
               </div>
+
+              {/* Bei nur einem Lieferland waere eine Auswahl mit einem
+                  Eintrag eine Attrappe — dann steht dort ein Satz, der das
+                  Gebiet benennt, bevor jemand die Adresse eintippt und erst
+                  beim Abschicken erfaehrt, dass daraus nichts wird. */}
+              {countryCodes.length > 1 ? (
+                <label className="block text-sm">
+                  <span className="text-ink/70">{t.checkoutPage.countryLabel}</span>
+                  <select
+                    name="country"
+                    value={country}
+                    onChange={(event) => setCountry(event.target.value)}
+                    autoComplete="country"
+                    className="mt-1 w-full border border-ink/20 bg-background px-3 py-2 focus:outline-none focus:border-forest"
+                  >
+                    {countryCodes.map((code) => (
+                      <option key={code} value={code}>
+                        {countryName(code, locale)}
+                      </option>
+                    ))}
+                  </select>
+                </label>
+              ) : (
+                <p className="text-xs text-ink/65">{t.checkoutPage.shippingRegionDeNote}</p>
+              )}
             </div>
           ) : null}
 
diff --git a/src/app/checkout/page.tsx b/src/app/checkout/page.tsx
index 55c3b7c..b5fb903 100644
--- a/src/app/checkout/page.tsx
+++ b/src/app/checkout/page.tsx
@@ -1,7 +1,7 @@
 import type { Metadata } from "next";
 import { getCurrentCustomer } from "@/lib/auth";
 import { getAddressesForCustomer } from "@/lib/account-data";
-import { getShippingTiers } from "@/lib/shipping";
+import { getShippingTiers, getShippingRegion } from "@/lib/shipping";
 import { getBulkDiscountTiers } from "@/lib/bulk-discount";
 import { getLocale } from "@/i18n/locale";
 import { getDictionary } from "@/i18n/get-dictionary";
@@ -20,7 +20,11 @@ export async function generateMetadata(): Promise<Metadata> {
 }
 
 export default async function CheckoutPage() {
-  const [tiers, bulkDiscountTiers] = await Promise.all([getShippingTiers(), getBulkDiscountTiers()]);
+  const [tiers, bulkDiscountTiers, shippingRegion] = await Promise.all([
+    getShippingTiers(),
+    getBulkDiscountTiers(),
+    getShippingRegion(),
+  ]);
   const tierValues = tiers.map((t) => ({
     minQuantity: t.minQuantity,
     maxQuantity: t.maxQuantity,
@@ -33,6 +37,7 @@ export default async function CheckoutPage() {
         tiers={tierValues}
         bulkDiscountTiers={bulkDiscountTiers}
         packstationSearchAvailable={isPackstationSearchConfigured()}
+        shippingRegion={shippingRegion}
       />;
 
   // getAddressesForCustomer sortiert Standardadresse (isDefault) zuerst, sonst
@@ -57,5 +62,6 @@ export default async function CheckoutPage() {
       tiers={tierValues}
       bulkDiscountTiers={bulkDiscountTiers}
       packstationSearchAvailable={isPackstationSearchConfigured()}
+        shippingRegion={shippingRegion}
     />;
 }
diff --git a/src/app/versand-zahlung/page.tsx b/src/app/versand-zahlung/page.tsx
index c8c5fa4..7286a69 100644
--- a/src/app/versand-zahlung/page.tsx
+++ b/src/app/versand-zahlung/page.tsx
@@ -1,6 +1,6 @@
 import type { Metadata } from "next";
 import { LegalPage } from "@/components/legal-page";
-import { getShippingTiers } from "@/lib/shipping";
+import { getShippingTiers, getShippingRegion } from "@/lib/shipping";
 import { formatPrice } from "@/lib/format";
 import { getLocale } from "@/i18n/locale";
 import { getDictionary } from "@/i18n/get-dictionary";
@@ -14,7 +14,7 @@ export const dynamic = "force-dynamic";
 export default async function VersandZahlungPage() {
   const locale = await getLocale();
   const t = getDictionary(locale);
-  const tiers = await getShippingTiers();
+  const [tiers, region] = await Promise.all([getShippingTiers(), getShippingRegion()]);
 
   const tierParagraphs =
     tiers.length > 0
@@ -41,6 +41,19 @@ export default async function VersandZahlungPage() {
           heading: t.versandZahlungPage.shippingHeading,
           paragraphs: [t.versandZahlungPage.shippingIntro, ...tierParagraphs, t.versandZahlungPage.pickupNote],
         },
+        {
+          // Eigener Abschnitt statt eines Nebensatzes im Versandtext: wohin
+          // geliefert wird, entscheidet vor dem Warenkorb, ob ein Kauf
+          // ueberhaupt zustande kommen kann. Welcher Satz hier steht, steuert
+          // der Admin-Bereich (Inhalte → Firmendaten → Liefergebiet) — und
+          // derselbe Wert weist im Checkout Bestellungen ausserhalb des
+          // Gebiets ab, die Seite kann also nicht etwas anderes behaupten als
+          // der Shop tut.
+          heading: t.versandZahlungPage.regionHeading,
+          paragraphs: [
+            region === "EU" ? t.versandZahlungPage.regionTextEu : t.versandZahlungPage.regionTextDe,
+          ],
+        },
         {
           heading: t.versandZahlungPage.paymentHeading,
           paragraphs: [t.versandZahlungPage.paymentText],
diff --git a/src/i18n/dictionaries/de.ts b/src/i18n/dictionaries/de.ts
index d4e9028..9a227f1 100644
--- a/src/i18n/dictionaries/de.ts
+++ b/src/i18n/dictionaries/de.ts
@@ -391,6 +391,9 @@ export const de: Dictionary = {
     tierRange: (min, max, price) => `${min}–${max} Gläser/Artikel: ${price}`,
     tierMinimum: (min, price) => `Ab ${min} Gläsern/Artikeln: ${price}`,
     pickupNote: "Alternativ kannst du deine Bestellung nach Absprache direkt bei uns in Altenmünster abholen. Dabei fallen keine Versandkosten an.",
+    regionHeading: "Liefergebiet",
+    regionTextDe: "Versand ist nur innerhalb Deutschlands möglich. Bestellungen mit einer Lieferadresse außerhalb Deutschlands können wir derzeit leider nicht annehmen.",
+    regionTextEu: "Versand ist in die gesamte Europäische Union möglich. Bestellungen mit einer Lieferadresse außerhalb der EU können wir derzeit leider nicht annehmen.",
     paymentHeading: "Zahlungsmethoden",
     paymentText: "Wir bieten Kreditkarte, SEPA-Lastschrift, Klarna, PayPal, Apple Pay und Google Pay über unseren Zahlungsdienstleister Stripe an. Eine Zahlung per Überweisung ist auf Anfrage möglich.",
     deliveryTimeHeading: "Lieferzeit",
@@ -1380,6 +1383,8 @@ export const de: Dictionary = {
     streetLabel: "Straße und Hausnummer",
     zipLabel: "PLZ",
     cityLabel: "Ort",
+    countryLabel: "Land",
+    shippingRegionDeNote: "Wir versenden derzeit ausschließlich innerhalb Deutschlands.",
     discountCodeLabel: "Gutscheincode (optional)",
     discountCodePlaceholder: "z.B. WABEN10",
     isGiftLabel: "Das ist ein Geschenk",
diff --git a/src/i18n/dictionaries/en.ts b/src/i18n/dictionaries/en.ts
index 84490d4..3f682a1 100644
--- a/src/i18n/dictionaries/en.ts
+++ b/src/i18n/dictionaries/en.ts
@@ -391,6 +391,9 @@ export const en: Dictionary = {
     tierRange: (min, max, price) => `${min}–${max} jars/items: ${price}`,
     tierMinimum: (min, price) => `From ${min} jars/items: ${price}`,
     pickupNote: "Alternatively, you can pick up your order directly from us in Altenmünster by arrangement; no shipping costs apply in that case.",
+    regionHeading: "Shipping region",
+    regionTextDe: "We ship within Germany only. Unfortunately we cannot currently accept orders with a delivery address outside Germany.",
+    regionTextEu: "We ship to the entire European Union. Unfortunately we cannot currently accept orders with a delivery address outside the EU.",
     paymentHeading: "Payment Methods",
     paymentText: "We offer credit card, SEPA direct debit, Klarna, PayPal, Apple Pay, and Google Pay via our payment provider Stripe. Payment by bank transfer is available on request.",
     deliveryTimeHeading: "Delivery Time",
@@ -1379,6 +1382,8 @@ export const en: Dictionary = {
     streetLabel: "Street and house number",
     zipLabel: "Postal code",
     cityLabel: "City",
+    countryLabel: "Country",
+    shippingRegionDeNote: "We currently ship within Germany only.",
     discountCodeLabel: "Discount code (optional)",
     discountCodePlaceholder: "e.g. WABEN10",
     isGiftLabel: "This is a gift",
diff --git a/src/i18n/dictionary-type.ts b/src/i18n/dictionary-type.ts
index 263cebc..2b77f7f 100644
--- a/src/i18n/dictionary-type.ts
+++ b/src/i18n/dictionary-type.ts
@@ -226,6 +226,10 @@ export interface Dictionary {
     tierRange: (min: number, max: number, price: string) => string;
     tierMinimum: (min: number, price: string) => string;
     pickupNote: string;
+    /** Liefergebiet — welcher Satz erscheint, steuert der Admin-Bereich. */
+    regionHeading: string;
+    regionTextDe: string;
+    regionTextEu: string;
     paymentHeading: string;
     paymentText: string;
     deliveryTimeHeading: string;
@@ -1057,6 +1061,9 @@ export interface Dictionary {
     streetLabel: string;
     zipLabel: string;
     cityLabel: string;
+    countryLabel: string;
+    /** Hinweis neben der Laenderauswahl, wenn nur nach Deutschland geliefert wird. */
+    shippingRegionDeNote: string;
     discountCodeLabel: string;
     discountCodePlaceholder: string;
     isGiftLabel: string;
diff --git a/src/lib/content-registry.ts b/src/lib/content-registry.ts
index 0854a95..205bdbf 100644
--- a/src/lib/content-registry.ts
+++ b/src/lib/content-registry.ts
@@ -1,11 +1,14 @@
 import { getDictionary } from "@/i18n/get-dictionary";
 import { siteConfig } from "@/lib/site-config";
+import { DEFAULT_SHIPPING_REGION } from "@/lib/shipping-region";
 import type { Locale } from "@/i18n/config";
 import type { TitledText, LegalSectionContent } from "@/i18n/dictionary-type";
 
 export type ContentFieldType =
   | "text"
   | "textarea"
+  /** Feste Auswahl statt freiem Text — siehe "options" an ContentFieldDef. */
+  | "select"
   | "list-simple"
   | "list-titled"
   | "list-numbered"
@@ -23,6 +26,13 @@ export interface ContentFieldDef {
   localized: boolean;
   /** Liefert den aktuellen Fallback-Text im selben Format, das der Parser fuer diesen Typ erwartet. */
   getDefault: (locale: Locale) => string;
+  /**
+   * Nur bei type: "select" — die waehlbaren Werte. Ein freies Textfeld waere
+   * hier falsch: ein Tippfehler im Liefergebiet wuerde stillschweigend auf
+   * den Vorgabewert zurueckfallen, und niemand saehe, dass die Umstellung
+   * nicht gegriffen hat.
+   */
+  options?: { value: string; labelDe: string; labelEn: string }[];
 }
 
 function joinSimpleList(items: string[]): string {
@@ -56,6 +66,25 @@ export const CONTENT_REGISTRY: ContentFieldDef[] = [
   { key: "company.zip", group: "company", labelDe: "PLZ", labelEn: "ZIP", type: "text", localized: false, getDefault: () => siteConfig.address.zip },
   { key: "company.city", group: "company", labelDe: "Ort", labelEn: "City", type: "text", localized: false, getDefault: () => siteConfig.address.city },
 
+  // --- Liefergebiet ---
+  // Steuert dreierlei zugleich: die Laenderauswahl im Checkout, die
+  // verbindliche Pruefung beim Anlegen der Bestellung (api/checkout/route.ts)
+  // und den Hinweis auf der Seite "Versand und Zahlung". Bewusst eine
+  // Auswahl und kein Freitext — siehe "options" oben.
+  {
+    key: "shipping.region",
+    group: "company",
+    labelDe: "Liefergebiet",
+    labelEn: "Shipping region",
+    type: "select",
+    localized: false,
+    getDefault: () => DEFAULT_SHIPPING_REGION,
+    options: [
+      { value: "DE", labelDe: "Nur Deutschland", labelEn: "Germany only" },
+      { value: "EU", labelDe: "Europäische Union", labelEn: "European Union" },
+    ],
+  },
+
   // --- Homepage (lokalisiert) ---
   { key: "home.hero.intro", group: "home", labelDe: "Hero: Einleitungstext", labelEn: "Hero: Intro text", type: "textarea", localized: true, getDefault: (l) => getDictionary(l).home.hero.intro },
   { key: "home.hero.footnote", group: "home", labelDe: "Hero: Fußnote", labelEn: "Hero: Footnote", type: "text", localized: true, getDefault: (l) => getDictionary(l).home.hero.footnote },
diff --git a/src/lib/shipping-region.test.ts b/src/lib/shipping-region.test.ts
new file mode 100644
index 0000000..41a9a6e
--- /dev/null
+++ b/src/lib/shipping-region.test.ts
@@ -0,0 +1,91 @@
+/**
+ * Tests fuer das Liefergebiet.
+ *
+ * Die Frage "darf in dieses Land geliefert werden" entscheidet, ob eine
+ * Bestellung zustande kommt. Ein Fehler in die eine Richtung sperrt zahlende
+ * Kundschaft aus, einer in die andere erzeugt Lieferungen in Laender, fuer
+ * die weder Steuer noch Zoll geklaert sind.
+ */
+import { describe, test, expect } from "vitest";
+import {
+  DEFAULT_SHIPPING_REGION,
+  EU_COUNTRY_CODES,
+  allowedCountryCodes,
+  isCountryAllowed,
+  parseShippingRegion,
+} from "./shipping-region";
+
+describe("parseShippingRegion", () => {
+  test("erkennt die beiden gueltigen Werte", () => {
+    expect(parseShippingRegion("DE")).toBe("DE");
+    expect(parseShippingRegion("EU")).toBe("EU");
+  });
+
+  test("ist unempfindlich gegen Schreibweise und Leerzeichen", () => {
+    expect(parseShippingRegion(" eu ")).toBe("EU");
+    expect(parseShippingRegion("de")).toBe("DE");
+  });
+
+  test("faellt bei fehlendem oder unsinnigem Wert auf den engsten Zuschnitt zurueck", () => {
+    // Wichtige Richtung: im Zweifel WENIGER Laender, nicht mehr. Ein Shop
+    // liefert nie versehentlich weiter, als er wollte.
+    expect(parseShippingRegion(null)).toBe("DE");
+    expect(parseShippingRegion("")).toBe("DE");
+    expect(parseShippingRegion("WELTWEIT")).toBe("DE");
+    expect(DEFAULT_SHIPPING_REGION).toBe("DE");
+  });
+});
+
+describe("allowedCountryCodes", () => {
+  test('"DE" erlaubt genau ein Land', () => {
+    expect(allowedCountryCodes("DE")).toEqual(["DE"]);
+  });
+
+  test('"EU" erlaubt die 27 Mitgliedstaaten, sortiert und ohne Dubletten', () => {
+    const codes = allowedCountryCodes("EU");
+    expect(codes).toHaveLength(27);
+    expect(codes).toEqual([...codes].sort());
+    expect(new Set(codes).size).toBe(27);
+  });
+
+  test("Drittlaender in Europa sind NICHT enthalten", () => {
+    // Schweiz, Norwegen und das Vereinigte Koenigreich liegen in Europa, sind
+    // aber Zollausland — dorthin zu liefern braucht mehr als einen Haken im
+    // Admin-Bereich.
+    const codes = allowedCountryCodes("EU");
+    expect(codes).not.toContain("CH");
+    expect(codes).not.toContain("NO");
+    expect(codes).not.toContain("GB");
+  });
+
+  test("Griechenland steht als ISO-Code GR, nicht als EL", () => {
+    expect(EU_COUNTRY_CODES as readonly string[]).toContain("GR");
+    expect(EU_COUNTRY_CODES as readonly string[]).not.toContain("EL");
+  });
+});
+
+describe("isCountryAllowed", () => {
+  test('bei "DE" kommt nur Deutschland durch', () => {
+    expect(isCountryAllowed("DE", "DE")).toBe(true);
+    expect(isCountryAllowed("DE", "AT")).toBe(false);
+    expect(isCountryAllowed("DE", "FR")).toBe(false);
+  });
+
+  test('bei "EU" kommen Mitgliedstaaten durch, Drittlaender nicht', () => {
+    expect(isCountryAllowed("EU", "AT")).toBe(true);
+    expect(isCountryAllowed("EU", "DE")).toBe(true);
+    expect(isCountryAllowed("EU", "CH")).toBe(false);
+    expect(isCountryAllowed("EU", "US")).toBe(false);
+  });
+
+  test("akzeptiert Kleinschreibung und Leerzeichen aus dem Formular", () => {
+    expect(isCountryAllowed("EU", " at ")).toBe(true);
+    expect(isCountryAllowed("DE", "de")).toBe(true);
+  });
+
+  test("ein fehlendes Land ist nie erlaubt", () => {
+    expect(isCountryAllowed("EU", null)).toBe(false);
+    expect(isCountryAllowed("EU", "")).toBe(false);
+    expect(isCountryAllowed("EU", "   ")).toBe(false);
+  });
+});
diff --git a/src/lib/shipping-region.ts b/src/lib/shipping-region.ts
new file mode 100644
index 0000000..5ec0e34
--- /dev/null
+++ b/src/lib/shipping-region.ts
@@ -0,0 +1,64 @@
+/**
+ * Liefergebiet des Shops.
+ *
+ * Bewusst eine ausdrueckliche Entscheidung und keine Ableitung aus den
+ * Versandstaffeln: ob in ein Land geliefert wird, haengt nicht am Preis,
+ * sondern an Steuerpflichten (Umsatzsteuer im Bestimmungsland ab der
+ * EU-Lieferschwelle), Zoll und den eigenen Kapazitaeten. Das gehoert
+ * entschieden, nicht erraten.
+ *
+ * Reine Logik ohne Datenbankzugriff — dieselbe Trennung wie bei
+ * shipping-calc.ts, damit sie sich ohne DATABASE_URL testen laesst. Den
+ * aktuell gepflegten Wert liest lib/shipping.ts.
+ */
+
+export const SHIPPING_REGIONS = ["DE", "EU"] as const;
+export type ShippingRegion = (typeof SHIPPING_REGIONS)[number];
+
+/** Vorgabe: der engste Zuschnitt. Ein Shop liefert nie versehentlich weiter, als er wollte. */
+export const DEFAULT_SHIPPING_REGION: ShippingRegion = "DE";
+
+/**
+ * Die 27 Mitgliedstaaten der Europaeischen Union als ISO-3166-1-alpha-2.
+ *
+ * Bewusst die EU und nicht "Europa" im geografischen Sinn: die Schweiz,
+ * Norwegen und das Vereinigte Koenigreich liegen in Europa, sind aber
+ * Drittlaender mit Zollanmeldung und Einfuhrumsatzsteuer. Wer sie beliefern
+ * will, braucht mehr als einen Haken im Admin-Bereich.
+ *
+ * Griechenland steht als "GR" (ISO), nicht als "EL" (EU-interne Schreibweise).
+ */
+export const EU_COUNTRY_CODES = [
+  "AT", "BE", "BG", "CY", "CZ", "DE", "DK", "EE", "ES", "FI",
+  "FR", "GR", "HR", "HU", "IE", "IT", "LT", "LU", "LV", "MT",
+  "NL", "PL", "PT", "RO", "SE", "SI", "SK",
+] as const;
+
+/** Wandelt den in der Datenbank gepflegten Text in ein Liefergebiet. */
+export function parseShippingRegion(raw: string | null | undefined): ShippingRegion {
+  const value = raw?.trim().toUpperCase();
+  return SHIPPING_REGIONS.includes(value as ShippingRegion)
+    ? (value as ShippingRegion)
+    : DEFAULT_SHIPPING_REGION;
+}
+
+/**
+ * Alle Laender, in die geliefert wird — aufsteigend sortiert, damit die
+ * Auswahl im Checkout eine stabile Reihenfolge hat.
+ */
+export function allowedCountryCodes(region: ShippingRegion): string[] {
+  return region === "EU" ? [...EU_COUNTRY_CODES].sort() : ["DE"];
+}
+
+/**
+ * Darf in dieses Land geliefert werden?
+ *
+ * Gross-/Kleinschreibung und Leerzeichen werden abgefangen: der Wert kommt
+ * aus einem Formularfeld, und eine Bestellung an einer Schreibweise scheitern
+ * zu lassen waere kein Schutz, sondern ein Fehler.
+ */
+export function isCountryAllowed(region: ShippingRegion, country: string | null | undefined): boolean {
+  const code = country?.trim().toUpperCase();
+  if (!code) return false;
+  return allowedCountryCodes(region).includes(code);
+}
diff --git a/src/lib/shipping.ts b/src/lib/shipping.ts
index c3e5a4d..a3270ea 100644
--- a/src/lib/shipping.ts
+++ b/src/lib/shipping.ts
@@ -1,7 +1,26 @@
+import { cache } from "react";
 import { prisma } from "@/lib/prisma";
 import { resolveShippingCostCents } from "@/lib/shipping-calc";
+import { getContentValue } from "@/lib/content";
+import { parseShippingRegion, type ShippingRegion } from "@/lib/shipping-region";
 import type { ShippingTier } from "@/generated/prisma/client";
 
+/**
+ * Aktuell gepflegtes Liefergebiet (Admin-Bereich → Inhalte → Firmendaten).
+ *
+ * In React-cache() gehuellt wie getCompanyInfo: der Wert wird beim Rendern
+ * einer Checkout-Seite mehrfach gebraucht (Laenderauswahl im Formular,
+ * Hinweistext daneben), und das waeren sonst mehrere Abfragen derselben einen
+ * Zeile. Die Deduplizierung gilt je Request — eine Umstellung im
+ * Admin-Bereich wirkt sofort.
+ */
+export const getShippingRegion = cache(async (): Promise<ShippingRegion> => {
+  // Nicht lokalisiert: das Liefergebiet ist eine Tatsache des Betriebs, keine
+  // Textfassung. getContentValue liefert fuer solche Schluessel unabhaengig
+  // von der Sprache denselben Wert.
+  return parseShippingRegion(await getContentValue("shipping.region", "de"));
+});
+
 export async function getShippingTiers(): Promise<ShippingTier[]> {
   return prisma.shippingTier.findMany({ orderBy: { minQuantity: "asc" } });
 }