diff --git a/app/components/PricingPlanCard.vue b/app/components/PricingPlanCard.vue
index 117fb4d7..73bd6925 100644
--- a/app/components/PricingPlanCard.vue
+++ b/app/components/PricingPlanCard.vue
@@ -27,7 +27,7 @@
       <h3 :class="compact ? 'text-lg' : 'text-xl'" class="font-bold">{{ plan.name }}</h3>
       <div :class="compact ? 'mt-2' : 'mt-4'" class="flex items-baseline gap-1">
         <span :class="compact ? 'text-2xl' : 'text-4xl'" class="font-extrabold">
-          {{ formatPrice(plan.monthlyPrice) }}
+          {{ formatPriceLocalized(plan.monthlyPrice, currencyContext) }}
         </span>
         <span class="text-sm text-gray-500 dark:text-gray-400"> / month </span>
       </div>
@@ -70,7 +70,7 @@
 </template>
 
 <script setup lang="ts">
-  import { formatPrice, type PricingPlan } from '~/utils/pricing'
+  import { formatPriceLocalized, type PricingPlan } from '~/utils/pricing'
 
   interface Props {
     plan: PricingPlan
@@ -90,8 +90,18 @@
   }>()
 
   const userStore = useUserStore()
+  const { data } = useAuth()
   const config = useRuntimeConfig()
   const subscriptionsEnabled = computed(() => config.public.subscriptionsEnabled)
+  const { timezone } = useFormat()
+
+  const currencyContext = computed(() => ({
+    country: userStore.profile?.country,
+    preferredCurrency: userStore.profile?.currencyPreference,
+    profileTimezone: (data.value?.user as any)?.timezone || timezone.value,
+    browserTimezone: import.meta.client ? Intl.DateTimeFormat().resolvedOptions().timeZone : null,
+    locale: import.meta.client ? navigator.language : null
+  }))
 
   const isCurrentPlan = computed(() => {
     const currentTier = userStore.user?.subscriptionTier?.toLowerCase()
diff --git a/app/components/landing/PricingPlans.vue b/app/components/landing/PricingPlans.vue
index 55b67883..37f2a000 100644
--- a/app/components/landing/PricingPlans.vue
+++ b/app/components/landing/PricingPlans.vue
@@ -70,7 +70,7 @@
 
           <div class="mt-4 flex items-baseline gap-1">
             <span class="text-4xl font-extrabold">{{
-              formatPrice(getPrice(plan, billingInterval))
+              formatPriceLocalized(getPrice(plan, billingInterval), currencyContext)
             }}</span>
 
             <span class="text-sm text-gray-500 dark:text-gray-400">
@@ -128,23 +128,48 @@
   import {
     PRICING_PLANS,
     calculateAnnualSavings,
-    formatPrice,
+    formatPriceLocalized,
     getPrice,
     getStripePriceId,
     type BillingInterval,
     type PricingPlan
   } from '~/utils/pricing'
 
-  const { status } = useAuth()
+  const { status, data } = useAuth()
   const userStore = useUserStore()
   const { createCheckoutSession, openCustomerPortal } = useStripe()
   const config = useRuntimeConfig()
+  const { timezone } = useFormat()
 
   const billingInterval = ref<BillingInterval>('annual')
   const loading = ref(false)
   const selectedPlan = ref<string | null>(null)
   const subscriptionsEnabled = computed(() => config.public.subscriptionsEnabled)
 
+  const browserTimezone = computed(() => {
+    if (!import.meta.client) return null
+    return Intl.DateTimeFormat().resolvedOptions().timeZone
+  })
+
+  const browserLocale = computed(() => {
+    if (!import.meta.client) return null
+    return navigator.language
+  })
+
+  const currencyContext = computed(() => ({
+    country: userStore.profile?.country,
+    preferredCurrency: userStore.profile?.currencyPreference,
+    profileTimezone: (data.value?.user as any)?.timezone || timezone.value,
+    browserTimezone: browserTimezone.value,
+    locale: browserLocale.value
+  }))
+
+  onMounted(() => {
+    if (status.value === 'authenticated' && !userStore.profile) {
+      userStore.fetchProfile()
+    }
+  })
+
   function isCurrentPlan(plan: PricingPlan): boolean {
     if (!userStore.user || status.value !== 'authenticated') return false
     const currentTier = userStore.user.subscriptionTier?.toLowerCase()
diff --git a/app/components/profile/BasicSettings.vue b/app/components/profile/BasicSettings.vue
index 2b4ce0b6..f79ad6f1 100644
--- a/app/components/profile/BasicSettings.vue
+++ b/app/components/profile/BasicSettings.vue
@@ -437,6 +437,43 @@
           }}</span>
         </p>
       </div>
+      <!-- Currency -->
+      <div class="group relative">
+        <div class="flex items-center gap-1 mb-1">
+          <label class="text-sm text-muted">Currency</label>
+          <button
+            class="opacity-0 group-hover:opacity-100 transition-opacity p-0.5 rounded hover:bg-gray-100 dark:hover:bg-gray-800"
+            @click="startEdit('currencyPreference')"
+          >
+            <UIcon name="i-heroicons-pencil" class="w-3 h-3 text-muted hover:text-primary" />
+          </button>
+        </div>
+        <div v-if="editingField === 'currencyPreference'" class="flex gap-2 w-full relative z-50">
+          <USelectMenu
+            v-model="currencyModel"
+            :items="currencyOptions"
+            option-attribute="label"
+            :search-attributes="['label', 'code']"
+            size="sm"
+            class="flex-1"
+            searchable
+            searchable-placeholder="Search currency..."
+            autofocus
+            :ui="{ content: 'w-full min-w-[var(--reka-popper-anchor-width)]' }"
+            @update:model-value="saveField"
+          />
+        </div>
+        <div v-else class="space-y-1">
+          <p class="font-medium text-lg">
+            {{
+              modelValue.currencyPreference
+                ? getCurrencyLabel(modelValue.currencyPreference)
+                : 'Auto (Based on location)'
+            }}
+          </p>
+          <p class="text-xs text-gray-500 dark:text-gray-400">In use: {{ currentCurrencyLabel }}</p>
+        </div>
+      </div>
       <!-- Timezone -->
       <div class="lg:col-span-2 group relative">
         <div class="flex items-center gap-1 mb-1">
@@ -542,6 +579,7 @@
 
 <script setup lang="ts">
   import { countries } from '~/utils/countries'
+  import { ACCEPTED_CURRENCIES, getCurrencyLabel, resolveCurrencyContext } from '~/utils/currency'
   const props = defineProps<{
     modelValue: any
     email: string
@@ -564,6 +602,33 @@
     }
   })
 
+  const currencyOptions = computed(() => [
+    { code: '', label: 'Auto (Based on location)' },
+    ...ACCEPTED_CURRENCIES
+  ])
+
+  const currencyModel = computed({
+    get: () => {
+      const current = editValue.value ? editValue.value.toString() : ''
+      return currencyOptions.value.find((c) => c.code === current)
+    },
+    set: (val: any) => {
+      editValue.value = val?.code || ''
+    }
+  })
+
+  const currentCurrencyLabel = computed(() => {
+    const resolved = resolveCurrencyContext({
+      preferredCurrency: props.modelValue.currencyPreference,
+      country: props.modelValue.country,
+      profileTimezone: props.modelValue.timezone,
+      browserTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      locale: typeof navigator !== 'undefined' ? navigator.language : null
+    })
+
+    return `${resolved.currency} - ${getCurrencyLabel(resolved.currency)}`
+  })
+
   const countriesWithLabel = computed(() =>
     countries.map((c) => ({
       ...c,
diff --git a/app/pages/profile/settings.vue b/app/pages/profile/settings.vue
index e82fa521..6426d131 100644
--- a/app/pages/profile/settings.vue
+++ b/app/pages/profile/settings.vue
@@ -105,7 +105,8 @@
     city: '',
     state: '',
     country: '',
-    timezone: ''
+    timezone: '',
+    currencyPreference: null
   })
 
   const sportSettings = ref<any[]>([])
diff --git a/app/plugins/currency.client.ts b/app/plugins/currency.client.ts
new file mode 100644
index 00000000..032f0759
--- /dev/null
+++ b/app/plugins/currency.client.ts
@@ -0,0 +1,12 @@
+import { setCurrencyRates } from '~/utils/currency'
+
+export default defineNuxtPlugin(async () => {
+  try {
+    const data = await $fetch<{ rates: Record<string, number> }>('/api/currency/rates')
+    if (data?.rates) {
+      setCurrencyRates(data.rates)
+    }
+  } catch (error) {
+    console.warn('[CurrencyRates] Failed to load rates on client.', error)
+  }
+})
diff --git a/app/utils/currency.ts b/app/utils/currency.ts
new file mode 100644
index 00000000..0bbc4c33
--- /dev/null
+++ b/app/utils/currency.ts
@@ -0,0 +1,228 @@
+export interface CurrencyContext {
+  country?: string | null
+  preferredCurrency?: string | null
+  profileTimezone?: string | null
+  browserTimezone?: string | null
+  locale?: string | null
+}
+
+const COUNTRY_ALIASES: Record<string, string> = {
+  'united states': 'US',
+  'united states of america': 'US',
+  usa: 'US',
+  uk: 'GB',
+  'united kingdom': 'GB',
+  england: 'GB',
+  scotland: 'GB',
+  wales: 'GB',
+  'northern ireland': 'GB',
+  russia: 'RU',
+  korea: 'KR',
+  'south korea': 'KR',
+  'republic of korea': 'KR',
+  'north korea': 'KP',
+  'new zealand': 'NZ'
+}
+
+const COUNTRY_TO_CURRENCY: Record<string, string> = {
+  US: 'USD',
+  CA: 'CAD',
+  MX: 'MXN',
+  BR: 'BRL',
+  AR: 'ARS',
+  CL: 'CLP',
+  GB: 'GBP',
+  IE: 'EUR',
+  FR: 'EUR',
+  DE: 'EUR',
+  ES: 'EUR',
+  IT: 'EUR',
+  NL: 'EUR',
+  BE: 'EUR',
+  PT: 'EUR',
+  AT: 'EUR',
+  FI: 'EUR',
+  NO: 'NOK',
+  SE: 'SEK',
+  DK: 'DKK',
+  CH: 'CHF',
+  JP: 'JPY',
+  KR: 'KRW',
+  IN: 'INR',
+  AU: 'AUD',
+  NZ: 'NZD',
+  SG: 'SGD',
+  HK: 'HKD',
+  ZA: 'ZAR'
+}
+
+const CURRENCY_LABELS: Record<string, string> = {
+  USD: 'US Dollar',
+  EUR: 'Euro',
+  GBP: 'British Pound',
+  CAD: 'Canadian Dollar',
+  AUD: 'Australian Dollar',
+  NZD: 'New Zealand Dollar',
+  JPY: 'Japanese Yen',
+  CHF: 'Swiss Franc',
+  SEK: 'Swedish Krona',
+  NOK: 'Norwegian Krone',
+  DKK: 'Danish Krone',
+  INR: 'Indian Rupee',
+  BRL: 'Brazilian Real',
+  MXN: 'Mexican Peso',
+  KRW: 'South Korean Won',
+  SGD: 'Singapore Dollar',
+  HKD: 'Hong Kong Dollar',
+  ZAR: 'South African Rand',
+  ARS: 'Argentine Peso',
+  CLP: 'Chilean Peso'
+}
+
+const DEFAULT_CURRENCY_RATES: Record<string, number> = {
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  CAD: 1.35,
+  AUD: 1.55,
+  NZD: 1.65,
+  JPY: 147,
+  CHF: 0.9,
+  SEK: 10.2,
+  NOK: 10.6,
+  DKK: 6.9,
+  INR: 83,
+  BRL: 4.95,
+  MXN: 17.2,
+  KRW: 1340,
+  SGD: 1.34,
+  HKD: 7.8,
+  ZAR: 18.4,
+  ARS: 1100,
+  CLP: 960
+}
+
+let dynamicRates: Record<string, number> | null = null
+
+const TIMEZONE_HINTS: Array<[string, string]> = [
+  ['Europe/London', 'GBP'],
+  ['Europe/Dublin', 'EUR'],
+  ['Europe/', 'EUR'],
+  ['America/Toronto', 'CAD'],
+  ['America/Vancouver', 'CAD'],
+  ['America/Montreal', 'CAD'],
+  ['America/Edmonton', 'CAD'],
+  ['America/Winnipeg', 'CAD'],
+  ['America/Mexico', 'MXN'],
+  ['America/Sao_Paulo', 'BRL'],
+  ['America/Argentina', 'ARS'],
+  ['America/Santiago', 'CLP'],
+  ['America/', 'USD'],
+  ['Asia/Tokyo', 'JPY'],
+  ['Asia/Seoul', 'KRW'],
+  ['Asia/Kolkata', 'INR'],
+  ['Asia/Singapore', 'SGD'],
+  ['Asia/Hong_Kong', 'HKD'],
+  ['Australia/', 'AUD'],
+  ['Pacific/Auckland', 'NZD'],
+  ['Africa/Johannesburg', 'ZAR']
+]
+
+export const ACCEPTED_CURRENCIES = Object.keys(DEFAULT_CURRENCY_RATES)
+  .sort()
+  .map((code) => ({
+    code,
+    label: `${code} - ${CURRENCY_LABELS[code] || code}`
+  }))
+
+export function setCurrencyRates(rates: Record<string, number>) {
+  dynamicRates = { ...rates }
+}
+
+function getRates(): Record<string, number> {
+  return dynamicRates || DEFAULT_CURRENCY_RATES
+}
+
+function normalizeCountryCode(country?: string | null): string | undefined {
+  if (!country) return undefined
+  const trimmed = country.trim()
+  if (!trimmed) return undefined
+  if (trimmed.length === 2 || trimmed.length === 3) {
+    return trimmed.toUpperCase()
+  }
+  const normalized = trimmed.toLowerCase()
+  return COUNTRY_ALIASES[normalized] || undefined
+}
+
+function resolveCurrencyFromTimezone(timezone?: string | null): string | undefined {
+  if (!timezone) return undefined
+  const normalized = timezone.trim()
+  for (const [hint, currency] of TIMEZONE_HINTS) {
+    if (normalized.startsWith(hint)) return currency
+  }
+  return undefined
+}
+
+function resolveCountryFromLocale(locale?: string | null): string | undefined {
+  if (!locale) return undefined
+  const normalized = locale.trim()
+  if (!normalized) return undefined
+  const parts = normalized.split(/[-_]/)
+  const region = parts[parts.length - 1]
+  if (region && region.length === 2) return region.toUpperCase()
+  return undefined
+}
+
+function getDefaultLocale(): string {
+  if (typeof navigator !== 'undefined' && navigator.language) {
+    return navigator.language
+  }
+  return 'en-US'
+}
+
+export function resolveCurrencyContext(context: CurrencyContext) {
+  const countryCode = normalizeCountryCode(context.country)
+  const preferredCurrency = context.preferredCurrency
+    ? context.preferredCurrency.trim().toUpperCase()
+    : undefined
+  const rates = getRates()
+  const hasPreferred = preferredCurrency && rates[preferredCurrency]
+  const currencyFromCountry = countryCode ? COUNTRY_TO_CURRENCY[countryCode] : undefined
+  const currencyFromProfileTz = resolveCurrencyFromTimezone(context.profileTimezone)
+  const currencyFromBrowserTz = resolveCurrencyFromTimezone(context.browserTimezone)
+  const localeCountry = resolveCountryFromLocale(context.locale)
+  const currencyFromLocale = localeCountry ? COUNTRY_TO_CURRENCY[localeCountry] : undefined
+  const currency =
+    (hasPreferred ? preferredCurrency : undefined) ||
+    currencyFromCountry ||
+    currencyFromProfileTz ||
+    currencyFromBrowserTz ||
+    currencyFromLocale ||
+    'USD'
+  const rate = rates[currency] || 1
+  const locale = context.locale || getDefaultLocale()
+
+  return {
+    currency,
+    rate,
+    locale,
+    countryCode
+  }
+}
+
+export function getCurrencyLabel(currency: string): string {
+  return CURRENCY_LABELS[currency] || currency
+}
+
+export function formatCurrencyFromUsd(amountUsd: number, context: CurrencyContext): string {
+  const { currency, rate, locale } = resolveCurrencyContext(context)
+  const converted = amountUsd * rate
+  const fractionDigits = converted % 1 === 0 ? 0 : 2
+
+  return new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  }).format(converted)
+}
diff --git a/app/utils/pricing.ts b/app/utils/pricing.ts
index aa7c5e8e..83bb84e0 100644
--- a/app/utils/pricing.ts
+++ b/app/utils/pricing.ts
@@ -1,3 +1,5 @@
+import { formatCurrencyFromUsd, type CurrencyContext } from '~/utils/currency'
+
 export type BillingInterval = 'monthly' | 'annual'
 export type PricingTier = 'free' | 'supporter' | 'pro'
 
@@ -84,6 +86,13 @@ export function formatPrice(price: number): string {
   }).format(price)
 }
 
+/**
+ * Format price using a localized currency context.
+ */
+export function formatPriceLocalized(price: number, context: CurrencyContext): string {
+  return formatCurrencyFromUsd(price, context)
+}
+
 /**
  * Get price for a specific interval
  */
diff --git a/prisma/migrations/20260208120500_add_currency_preference/migration.sql b/prisma/migrations/20260208120500_add_currency_preference/migration.sql
new file mode 100644
index 00000000..c4443d2f
--- /dev/null
+++ b/prisma/migrations/20260208120500_add_currency_preference/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN "currencyPreference" TEXT;
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index f54265ca..0dfa1205 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -66,6 +66,7 @@ model User {
   nickname                           String?
   nutritionTrackingEnabled           Boolean                      @default(true)
   recoverySensitivity                String?                      @default("MEDIUM")
+  currencyPreference                 String?
   lastLoginAt                        DateTime?
   lastLoginIp                        String?
   stripeCustomerId                   String?                      @unique
diff --git a/server/api/currency/rates.get.ts b/server/api/currency/rates.get.ts
new file mode 100644
index 00000000..aaadf427
--- /dev/null
+++ b/server/api/currency/rates.get.ts
@@ -0,0 +1,5 @@
+import { getCurrencyRates } from '../../utils/currencyRates'
+
+export default defineEventHandler(() => {
+  return getCurrencyRates()
+})
diff --git a/server/api/profile/dashboard.get.ts b/server/api/profile/dashboard.get.ts
index dfd6c960..02b3cf54 100644
--- a/server/api/profile/dashboard.get.ts
+++ b/server/api/profile/dashboard.get.ts
@@ -23,6 +23,7 @@ export default defineEventHandler(async (event) => {
         id: true,
         name: true,
         country: true,
+        currencyPreference: true,
         ftp: true,
         weight: true,
         maxHr: true,
@@ -249,6 +250,7 @@ export default defineEventHandler(async (event) => {
       profile: {
         name: user.name,
         country: user.country,
+        currencyPreference: user.currencyPreference,
         age: age,
         weight: recentWeight,
         ftp: effectiveFtp,
diff --git a/server/api/profile/index.get.ts b/server/api/profile/index.get.ts
index 531bc836..ac1b1135 100644
--- a/server/api/profile/index.get.ts
+++ b/server/api/profile/index.get.ts
@@ -77,7 +77,8 @@ export default defineEventHandler(async (event) => {
         city: true,
         state: true,
         country: true,
-        timezone: true
+        timezone: true,
+        currencyPreference: true
       }
     })
 
@@ -123,6 +124,7 @@ export default defineEventHandler(async (event) => {
         state: user.state,
         country: user.country,
         timezone: user.timezone,
+        currencyPreference: user.currencyPreference,
         sportSettings: sportSettings
       }
     }
diff --git a/server/plugins/currency-rates.ts b/server/plugins/currency-rates.ts
new file mode 100644
index 00000000..768db57b
--- /dev/null
+++ b/server/plugins/currency-rates.ts
@@ -0,0 +1,5 @@
+import { refreshCurrencyRates } from '../utils/currencyRates'
+
+export default defineNitroPlugin(async () => {
+  await refreshCurrencyRates()
+})
diff --git a/server/utils/currencyRates.ts b/server/utils/currencyRates.ts
new file mode 100644
index 00000000..32108d3c
--- /dev/null
+++ b/server/utils/currencyRates.ts
@@ -0,0 +1,89 @@
+const SUPPORTED_CURRENCIES = [
+  'USD',
+  'EUR',
+  'GBP',
+  'CAD',
+  'AUD',
+  'NZD',
+  'JPY',
+  'CHF',
+  'SEK',
+  'NOK',
+  'DKK',
+  'INR',
+  'BRL',
+  'MXN',
+  'KRW',
+  'SGD',
+  'HKD',
+  'ZAR',
+  'ARS',
+  'CLP'
+]
+
+const FALLBACK_RATES: Record<string, number> = {
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  CAD: 1.35,
+  AUD: 1.55,
+  NZD: 1.65,
+  JPY: 147,
+  CHF: 0.9,
+  SEK: 10.2,
+  NOK: 10.6,
+  DKK: 6.9,
+  INR: 83,
+  BRL: 4.95,
+  MXN: 17.2,
+  KRW: 1340,
+  SGD: 1.34,
+  HKD: 7.8,
+  ZAR: 18.4,
+  ARS: 1100,
+  CLP: 960
+}
+
+let cachedRates: Record<string, number> = { ...FALLBACK_RATES }
+let lastUpdated: string | null = null
+let source = 'fallback'
+
+interface FrankfurterResponse {
+  amount: number
+  base: string
+  date: string
+  rates: Record<string, number>
+}
+
+export async function refreshCurrencyRates() {
+  try {
+    const response = await fetch('https://api.frankfurter.app/latest?from=USD')
+    if (!response.ok) {
+      throw new Error(`Frankfurter responded with ${response.status}`)
+    }
+    const data = (await response.json()) as FrankfurterResponse
+    const nextRates: Record<string, number> = { USD: 1 }
+
+    for (const code of SUPPORTED_CURRENCIES) {
+      if (code === 'USD') continue
+      const rate = data.rates?.[code]
+      if (typeof rate === 'number') {
+        nextRates[code] = rate
+      }
+    }
+
+    cachedRates = { ...FALLBACK_RATES, ...nextRates }
+    lastUpdated = data.date || new Date().toISOString().slice(0, 10)
+    source = 'frankfurter'
+  } catch (error) {
+    console.warn('[CurrencyRates] Failed to refresh rates, using fallback.', error)
+  }
+}
+
+export function getCurrencyRates() {
+  return {
+    rates: cachedRates,
+    lastUpdated,
+    source
+  }
+}
diff --git a/server/utils/schemas/profile.ts b/server/utils/schemas/profile.ts
index 918e8945..ad86730a 100644
--- a/server/utils/schemas/profile.ts
+++ b/server/utils/schemas/profile.ts
@@ -22,6 +22,7 @@ export const profileUpdateSchema = z.object({
   state: z.string().nullable().optional(),
   country: z.string().nullable().optional(),
   timezone: z.string().nullable().optional(),
+  currencyPreference: z.string().nullable().optional(),
 
   // AI Context
   aiContext: z.string().nullable().optional(),