diff --git a/app/src/entities/app-settings/types/currency-code.type.ts b/app/src/entities/app-settings/types/currency-code.type.ts
index 27845a2..cdd8437 100644
--- a/app/src/entities/app-settings/types/currency-code.type.ts
+++ b/app/src/entities/app-settings/types/currency-code.type.ts
@@ -1 +1 @@
-export type CurrencyCode = 'UAH' | 'USD' | 'EUR';
+export type CurrencyCode = string;
diff --git a/app/src/entities/currency/index.ts b/app/src/entities/currency/index.ts
new file mode 100644
index 0000000..f16a65c
--- /dev/null
+++ b/app/src/entities/currency/index.ts
@@ -0,0 +1,3 @@
+export { getDefaultCurrencies } from './lib/get-default-currencies';
+export type { CurrencyId } from './types/currency-id.type';
+export type { Currency } from './types/currency.type';
diff --git a/app/src/entities/currency/lib/get-default-currencies.ts b/app/src/entities/currency/lib/get-default-currencies.ts
new file mode 100644
index 0000000..db91919
--- /dev/null
+++ b/app/src/entities/currency/lib/get-default-currencies.ts
@@ -0,0 +1,101 @@
+import type { Currency } from '../types/currency.type';
+
+/**
+ * Seed list used only to initialize the `Currencies` sheet and as an offline
+ * fallback when Google Sheets is unavailable. The sheet remains the source of
+ * truth: new currencies can be added there without touching this list.
+ */
+export function getDefaultCurrencies(): Currency[] {
+  return [
+    {
+      id: 'uah',
+      code: 'UAH',
+      name: 'Ukrainian Hryvnia',
+      symbol: '₴',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'usd',
+      code: 'USD',
+      name: 'US Dollar',
+      symbol: '$',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'eur',
+      code: 'EUR',
+      name: 'Euro',
+      symbol: '€',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'rub',
+      code: 'RUB',
+      name: 'Russian Ruble',
+      symbol: '₽',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'pln',
+      code: 'PLN',
+      name: 'Polish Zloty',
+      symbol: 'zł',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'gbp',
+      code: 'GBP',
+      name: 'British Pound',
+      symbol: '£',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'chf',
+      code: 'CHF',
+      name: 'Swiss Franc',
+      symbol: 'CHF',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'cad',
+      code: 'CAD',
+      name: 'Canadian Dollar',
+      symbol: 'C$',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'try',
+      code: 'TRY',
+      name: 'Turkish Lira',
+      symbol: '₺',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: true,
+    },
+    {
+      id: 'jpy',
+      code: 'JPY',
+      name: 'Japanese Yen',
+      symbol: '¥',
+      decimalDigits: 0,
+      isDefault: true,
+      isEnabled: true,
+    },
+  ];
+}
diff --git a/app/src/entities/currency/types/currency-id.type.ts b/app/src/entities/currency/types/currency-id.type.ts
new file mode 100644
index 0000000..d5f1d42
--- /dev/null
+++ b/app/src/entities/currency/types/currency-id.type.ts
@@ -0,0 +1 @@
+export type CurrencyId = string;
diff --git a/app/src/entities/currency/types/currency.type.ts b/app/src/entities/currency/types/currency.type.ts
new file mode 100644
index 0000000..1cf0886
--- /dev/null
+++ b/app/src/entities/currency/types/currency.type.ts
@@ -0,0 +1,11 @@
+import type { CurrencyId } from './currency-id.type';
+
+export type Currency = {
+  id: CurrencyId;
+  code: string;
+  name: string;
+  symbol: string;
+  decimalDigits: number;
+  isDefault: boolean;
+  isEnabled: boolean;
+};
diff --git a/app/src/features/analyze-transactions/lib/analytics-row.mapper.test.ts b/app/src/features/analyze-transactions/lib/analytics-row.mapper.test.ts
index d6aa1d4..f0aabba 100644
--- a/app/src/features/analyze-transactions/lib/analytics-row.mapper.test.ts
+++ b/app/src/features/analyze-transactions/lib/analytics-row.mapper.test.ts
@@ -4,8 +4,9 @@ import { mapRowToCategoryStats, mapRowToMonthlyStats } from './analytics-row.map
 
 describe('analytics row mapper', () => {
   it('maps monthly stats rows', () => {
-    expect(mapRowToMonthlyStats(['2026-05', '1000', '250', '750'])).toEqual({
+    expect(mapRowToMonthlyStats(['2026-05', 'UAH', '1000', '250', '750'])).toEqual({
       balance: 750,
+      currency: 'UAH',
       expense: 250,
       income: 1000,
       label: 'May 2026',
@@ -14,9 +15,10 @@ describe('analytics row mapper', () => {
   });
 
   it('maps category stats rows', () => {
-    expect(mapRowToCategoryStats(['Food', 'expense', '350', '2'])).toEqual({
+    expect(mapRowToCategoryStats(['Food', 'expense', 'UAH', '350', '2'])).toEqual({
       categoryName: 'Food',
       count: 2,
+      currency: 'UAH',
       expense: 350,
       income: 0,
       kind: 'expense',
@@ -24,8 +26,27 @@ describe('analytics row mapper', () => {
     });
   });
 
+  it('maps income category stats rows', () => {
+    expect(mapRowToCategoryStats(['Salary', 'income', 'USD', '3000', '1'])).toEqual({
+      categoryName: 'Salary',
+      count: 1,
+      currency: 'USD',
+      expense: 0,
+      income: 3000,
+      kind: 'income',
+      total: 3000,
+    });
+  });
+
+  it('tolerates missing currency in monthly stats rows', () => {
+    const result = mapRowToMonthlyStats(['2026-05', '', '1000', '250', '750']);
+
+    expect(result).not.toBeNull();
+    expect(result?.currency).toBe('');
+  });
+
   it('skips invalid rows', () => {
-    expect(mapRowToMonthlyStats(['2026-05', 'bad', '250', '750'])).toBeNull();
-    expect(mapRowToCategoryStats(['Food', 'other', '350', '2'])).toBeNull();
+    expect(mapRowToMonthlyStats(['2026-05', 'UAH', 'bad', '250', '750'])).toBeNull();
+    expect(mapRowToCategoryStats(['Food', 'other', 'UAH', '350', '2'])).toBeNull();
   });
 });
diff --git a/app/src/features/analyze-transactions/lib/analytics-row.mapper.ts b/app/src/features/analyze-transactions/lib/analytics-row.mapper.ts
index 0532927..8a3c4c4 100644
--- a/app/src/features/analyze-transactions/lib/analytics-row.mapper.ts
+++ b/app/src/features/analyze-transactions/lib/analytics-row.mapper.ts
@@ -30,7 +30,7 @@ function isTransactionKind(value: string | undefined): value is TransactionKind
 }
 
 export function mapRowToMonthlyStats(row: string[]): MonthlyStats | null {
-  const [month, incomeValue, expenseValue, balanceValue] = row;
+  const [month, currency, incomeValue, expenseValue, balanceValue] = row;
   const income = parseAmount(incomeValue);
   const expense = parseAmount(expenseValue);
   const balance = parseAmount(balanceValue);
@@ -41,6 +41,7 @@ export function mapRowToMonthlyStats(row: string[]): MonthlyStats | null {
 
   return {
     balance,
+    currency: currency?.trim() || '',
     expense,
     income,
     label: formatMonthLabel(month),
@@ -49,7 +50,7 @@ export function mapRowToMonthlyStats(row: string[]): MonthlyStats | null {
 }
 
 export function mapRowToCategoryStats(row: string[]): CategoryStats | null {
-  const [categoryName, kind, totalValue, countValue] = row;
+  const [categoryName, kind, currency, totalValue, countValue] = row;
   const total = parseAmount(totalValue);
   const count = parseAmount(countValue);
 
@@ -60,6 +61,7 @@ export function mapRowToCategoryStats(row: string[]): CategoryStats | null {
   return {
     categoryName,
     count,
+    currency: currency?.trim() || '',
     expense: kind === 'expense' ? total : 0,
     income: kind === 'income' ? total : 0,
     kind,
diff --git a/app/src/features/analyze-transactions/lib/analytics-stats.service.test.ts b/app/src/features/analyze-transactions/lib/analytics-stats.service.test.ts
index 22d1097..34aad74 100644
--- a/app/src/features/analyze-transactions/lib/analytics-stats.service.test.ts
+++ b/app/src/features/analyze-transactions/lib/analytics-stats.service.test.ts
@@ -25,12 +25,12 @@ describe('readAnalyticsStats', () => {
   it('reads analytics from Google Sheets when stats are available', async () => {
     const ranges = new Map([
       [
-        'MonthlyStats!A2:D',
-        { range: 'MonthlyStats!A2:D', values: [['2026-05', '1000', '250', '750']] },
+        'MonthlyStats!A2:E',
+        { range: 'MonthlyStats!A2:E', values: [['2026-05', 'UAH', '1000', '250', '750']] },
       ],
       [
-        'CategoryStats!A2:D',
-        { range: 'CategoryStats!A2:D', values: [['Food', 'expense', '250', '1']] },
+        'CategoryStats!A2:E',
+        { range: 'CategoryStats!A2:E', values: [['Food', 'expense', 'UAH', '250', '1']] },
       ],
     ]);
 
@@ -45,8 +45,79 @@ describe('readAnalyticsStats', () => {
       }),
     ).resolves.toMatchObject({
       source: 'google-sheets',
-      monthlyStats: [{ month: '2026-05' }],
-      categoryStats: [{ categoryName: 'Food', kind: 'expense' }],
+      monthlyStats: [{ month: '2026-05', currency: 'UAH' }],
+      categoryStats: [{ categoryName: 'Food', kind: 'expense', currency: 'UAH' }],
+    });
+  });
+
+  it('forces local stats when forceLocal is true even with valid credentials', async () => {
+    const ranges = new Map([
+      [
+        'MonthlyStats!A2:E',
+        { range: 'MonthlyStats!A2:E', values: [['2026-05', 'UAH', '999', '999', '0']] },
+      ],
+      [
+        'CategoryStats!A2:E',
+        { range: 'CategoryStats!A2:E', values: [['Remote', 'expense', 'UAH', '999', '1']] },
+      ],
+    ]);
+
+    await expect(
+      readAnalyticsStats({
+        accessToken: 'token',
+        forceLocal: true,
+        googleSheetsClient: {
+          readRange: ({ range }) => Promise.resolve(ranges.get(range) ?? { range, values: [] }),
+        },
+        spreadsheetId: 'sheet-id',
+        transactions: [
+          createTransaction({
+            amount: 120,
+            categoryName: 'Food',
+            id: 'food',
+            kind: 'expense',
+            signedAmount: -120,
+          }),
+        ],
+      }),
+    ).resolves.toMatchObject({
+      source: 'local',
+      categoryStats: [{ categoryName: 'Food' }],
+    });
+  });
+
+  it('local analytics keeps UAH and USD as separate monthly and category entries', async () => {
+    await expect(
+      readAnalyticsStats({
+        accessToken: null,
+        spreadsheetId: null,
+        transactions: [
+          createTransaction({
+            id: 'uah',
+            amount: 100,
+            currency: 'UAH',
+            kind: 'expense',
+            signedAmount: -100,
+          }),
+          createTransaction({
+            id: 'usd',
+            amount: 50,
+            currency: 'USD',
+            kind: 'expense',
+            signedAmount: -50,
+          }),
+        ],
+      }),
+    ).resolves.toMatchObject({
+      source: 'local',
+      monthlyStats: expect.arrayContaining([
+        expect.objectContaining({ currency: 'UAH', expense: 100 }),
+        expect.objectContaining({ currency: 'USD', expense: 50 }),
+      ]),
+      categoryStats: expect.arrayContaining([
+        expect.objectContaining({ currency: 'UAH', categoryName: 'Category', expense: 100 }),
+        expect.objectContaining({ currency: 'USD', categoryName: 'Category', expense: 50 }),
+      ]),
     });
   });
 
diff --git a/app/src/features/analyze-transactions/lib/analytics-stats.service.ts b/app/src/features/analyze-transactions/lib/analytics-stats.service.ts
index 9708ec7..b6a1851 100644
--- a/app/src/features/analyze-transactions/lib/analytics-stats.service.ts
+++ b/app/src/features/analyze-transactions/lib/analytics-stats.service.ts
@@ -10,6 +10,7 @@ import type { CategoryStats, MonthlyStats } from '../types/analytics-stat.types'
 
 type ReadAnalyticsStatsParams = {
   accessToken: string | null;
+  forceLocal?: boolean;
   googleSheetsClient?: Pick<GoogleSheetsClient, 'readRange'>;
   spreadsheetId: string | null;
   transactions: Transaction[];
@@ -33,13 +34,14 @@ function isCategoryStats(value: CategoryStats | null): value is CategoryStats {
 
 export async function readAnalyticsStats({
   accessToken,
+  forceLocal = false,
   googleSheetsClient = createGoogleSheetsClient(),
   spreadsheetId,
   transactions,
 }: ReadAnalyticsStatsParams): Promise<AnalyticsStats> {
   const localStats = buildLocalAnalyticsStats(transactions);
 
-  if (!accessToken || !spreadsheetId) {
+  if (!accessToken || !spreadsheetId || forceLocal) {
     return localStats;
   }
 
@@ -56,8 +58,12 @@ export async function readAnalyticsStats({
         spreadsheetId,
       }),
     ]);
-    const monthlyStats = monthlyRange.values.map(mapRowToMonthlyStats).filter(isMonthlyStats);
-    const categoryStats = categoryRange.values.map(mapRowToCategoryStats).filter(isCategoryStats);
+    const monthlyStats = (monthlyRange.values ?? [])
+      .map(mapRowToMonthlyStats)
+      .filter(isMonthlyStats);
+    const categoryStats = (categoryRange.values ?? [])
+      .map(mapRowToCategoryStats)
+      .filter(isCategoryStats);
 
     if (!monthlyStats.length && !categoryStats.length) {
       return localStats;
diff --git a/app/src/features/analyze-transactions/lib/calculate-category-stats.test.ts b/app/src/features/analyze-transactions/lib/calculate-category-stats.test.ts
index c19794f..bf843af 100644
--- a/app/src/features/analyze-transactions/lib/calculate-category-stats.test.ts
+++ b/app/src/features/analyze-transactions/lib/calculate-category-stats.test.ts
@@ -51,6 +51,7 @@ describe('calculateCategoryStats', () => {
       {
         categoryName: 'Food',
         count: 2,
+        currency: 'UAH',
         expense: 350,
         income: 0,
         kind: 'expense',
@@ -59,6 +60,7 @@ describe('calculateCategoryStats', () => {
       {
         categoryName: 'Salary',
         count: 1,
+        currency: 'UAH',
         expense: 0,
         income: 1000,
         kind: 'income',
@@ -66,6 +68,58 @@ describe('calculateCategoryStats', () => {
       },
     ]);
   });
+
+  it('groups by category and currency separately — never mixes currencies', () => {
+    const result = calculateCategoryStats([
+      createTransaction({
+        amount: 100,
+        categoryName: 'Food',
+        currency: 'UAH',
+        id: 'food-uah',
+        kind: 'expense',
+        signedAmount: -100,
+      }),
+      createTransaction({
+        amount: 50,
+        categoryName: 'Food',
+        currency: 'USD',
+        id: 'food-usd',
+        kind: 'expense',
+        signedAmount: -50,
+      }),
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ categoryName: 'Food', currency: 'UAH', expense: 100 }),
+        expect.objectContaining({ categoryName: 'Food', currency: 'USD', expense: 50 }),
+      ]),
+    );
+  });
+
+  it('sums same-currency transactions in the same category', () => {
+    expect(
+      calculateCategoryStats([
+        createTransaction({
+          amount: 100,
+          categoryName: 'Food',
+          id: 'food-1',
+          kind: 'expense',
+          signedAmount: -100,
+        }),
+        createTransaction({
+          amount: 50,
+          categoryName: 'Food',
+          id: 'food-2',
+          kind: 'expense',
+          signedAmount: -50,
+        }),
+      ]),
+    ).toEqual([
+      expect.objectContaining({ categoryName: 'Food', currency: 'UAH', expense: 150, count: 2 }),
+    ]);
+  });
 });
 
 describe('calculateTopCategories', () => {
diff --git a/app/src/features/analyze-transactions/lib/calculate-category-stats.ts b/app/src/features/analyze-transactions/lib/calculate-category-stats.ts
index 915f639..535cd62 100644
--- a/app/src/features/analyze-transactions/lib/calculate-category-stats.ts
+++ b/app/src/features/analyze-transactions/lib/calculate-category-stats.ts
@@ -3,15 +3,17 @@ import type { Transaction } from '@entities/transaction';
 import type { CategoryStats, TopCategoryStats } from '../types/analytics-stat.types';
 
 export function calculateCategoryStats(transactions: Transaction[]): CategoryStats[] {
-  const statsByCategory = new Map<string, CategoryStats>();
+  const statsByKey = new Map<string, CategoryStats>();
 
   transactions.forEach((transaction) => {
-    const statsKey = `${transaction.kind}:${transaction.categoryName}`;
+    const { currency } = transaction;
+    const statsKey = `${transaction.kind}:${transaction.categoryName}:${currency}`;
     const currentStats =
-      statsByCategory.get(statsKey) ??
+      statsByKey.get(statsKey) ??
       ({
         categoryName: transaction.categoryName,
         count: 0,
+        currency,
         expense: 0,
         income: 0,
         kind: transaction.kind,
@@ -26,10 +28,10 @@ export function calculateCategoryStats(transactions: Transaction[]): CategorySta
 
     currentStats.count += 1;
     currentStats.total += Math.abs(transaction.amount);
-    statsByCategory.set(statsKey, currentStats);
+    statsByKey.set(statsKey, currentStats);
   });
 
-  return [...statsByCategory.values()].sort((left, right) =>
+  return [...statsByKey.values()].sort((left, right) =>
     left.categoryName === right.categoryName
       ? left.kind.localeCompare(right.kind)
       : left.categoryName.localeCompare(right.categoryName),
diff --git a/app/src/features/analyze-transactions/lib/calculate-monthly-stats.test.ts b/app/src/features/analyze-transactions/lib/calculate-monthly-stats.test.ts
index 46a72e2..2b8aa45 100644
--- a/app/src/features/analyze-transactions/lib/calculate-monthly-stats.test.ts
+++ b/app/src/features/analyze-transactions/lib/calculate-monthly-stats.test.ts
@@ -50,6 +50,7 @@ describe('calculateMonthlyStats', () => {
     ).toEqual([
       {
         balance: 750,
+        currency: 'UAH',
         expense: 250,
         income: 1000,
         label: 'May 2026',
@@ -57,6 +58,7 @@ describe('calculateMonthlyStats', () => {
       },
       {
         balance: -100,
+        currency: 'UAH',
         expense: 100,
         income: 0,
         label: 'Jun 2026',
@@ -65,6 +67,46 @@ describe('calculateMonthlyStats', () => {
     ]);
   });
 
+  it('groups by month and currency separately — never mixes currencies', () => {
+    const result = calculateMonthlyStats([
+      createTransaction({
+        amount: 100,
+        currency: 'UAH',
+        date: '2026-05-01',
+        id: 'uah-expense',
+        kind: 'expense',
+        signedAmount: -100,
+      }),
+      createTransaction({
+        amount: 50,
+        currency: 'USD',
+        date: '2026-05-01',
+        id: 'usd-expense',
+        kind: 'expense',
+        signedAmount: -50,
+      }),
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ month: '2026-05', currency: 'UAH', expense: 100, income: 0 }),
+        expect.objectContaining({ month: '2026-05', currency: 'USD', expense: 50, income: 0 }),
+      ]),
+    );
+  });
+
+  it('sums same-currency transactions in the same month', () => {
+    expect(
+      calculateMonthlyStats([
+        createTransaction({ amount: 100, id: 'uah-1', kind: 'expense', signedAmount: -100 }),
+        createTransaction({ amount: 50, id: 'uah-2', kind: 'expense', signedAmount: -50 }),
+      ]),
+    ).toEqual([
+      expect.objectContaining({ currency: 'UAH', expense: 150, income: 0, balance: -150 }),
+    ]);
+  });
+
   it('returns empty stats for empty transactions', () => {
     expect(calculateMonthlyStats([])).toEqual([]);
   });
diff --git a/app/src/features/analyze-transactions/lib/calculate-monthly-stats.ts b/app/src/features/analyze-transactions/lib/calculate-monthly-stats.ts
index 7874ba6..eea5d2e 100644
--- a/app/src/features/analyze-transactions/lib/calculate-monthly-stats.ts
+++ b/app/src/features/analyze-transactions/lib/calculate-monthly-stats.ts
@@ -13,14 +13,17 @@ function formatMonthLabel(month: string) {
 }
 
 export function calculateMonthlyStats(transactions: Transaction[]): MonthlyStats[] {
-  const statsByMonth = new Map<string, MonthlyStats>();
+  const statsByKey = new Map<string, MonthlyStats>();
 
   transactions.forEach((transaction) => {
     const month = transaction.date.slice(0, 7);
+    const { currency } = transaction;
+    const key = `${month}:${currency}`;
     const currentStats =
-      statsByMonth.get(month) ??
+      statsByKey.get(key) ??
       ({
         balance: 0,
+        currency,
         expense: 0,
         income: 0,
         label: formatMonthLabel(month),
@@ -34,8 +37,12 @@ export function calculateMonthlyStats(transactions: Transaction[]): MonthlyStats
     }
 
     currentStats.balance += transaction.signedAmount;
-    statsByMonth.set(month, currentStats);
+    statsByKey.set(key, currentStats);
   });
 
-  return [...statsByMonth.values()].sort((left, right) => left.month.localeCompare(right.month));
+  return [...statsByKey.values()].sort((left, right) =>
+    left.month === right.month
+      ? left.currency.localeCompare(right.currency)
+      : left.month.localeCompare(right.month),
+  );
 }
diff --git a/app/src/features/analyze-transactions/model/useAnalyticsStats.ts b/app/src/features/analyze-transactions/model/useAnalyticsStats.ts
index aa8943f..56a9215 100644
--- a/app/src/features/analyze-transactions/model/useAnalyticsStats.ts
+++ b/app/src/features/analyze-transactions/model/useAnalyticsStats.ts
@@ -7,7 +7,7 @@ import { localStorageService } from '@shared/lib/storage/local-storage.service';
 import { readAnalyticsStats } from '../lib/analytics-stats.service';
 import type { AnalyticsStats } from '../types/analytics-stat.types';
 
-export function useAnalyticsStats(transactions: Transaction[]) {
+export function useAnalyticsStats(transactions: Transaction[], forceLocal = false) {
   const googleAuth = useGoogleAuth();
   const [stats, setStats] = useState<AnalyticsStats>({
     categoryStats: [],
@@ -22,6 +22,7 @@ export function useAnalyticsStats(transactions: Transaction[]) {
     async function loadStats() {
       const nextStats = await readAnalyticsStats({
         accessToken: googleAuth.accessToken,
+        forceLocal,
         spreadsheetId,
         transactions,
       });
@@ -36,7 +37,7 @@ export function useAnalyticsStats(transactions: Transaction[]) {
     return () => {
       isActive = false;
     };
-  }, [googleAuth.accessToken, transactions]);
+  }, [googleAuth.accessToken, forceLocal, transactions]);
 
   return stats;
 }
diff --git a/app/src/features/analyze-transactions/types/analytics-stat.types.ts b/app/src/features/analyze-transactions/types/analytics-stat.types.ts
index d0c7c75..de71acd 100644
--- a/app/src/features/analyze-transactions/types/analytics-stat.types.ts
+++ b/app/src/features/analyze-transactions/types/analytics-stat.types.ts
@@ -2,6 +2,7 @@ import type { TransactionKind } from '@entities/transaction';
 
 export type MonthlyStats = {
   balance: number;
+  currency: string;
   expense: number;
   income: number;
   label: string;
@@ -11,6 +12,7 @@ export type MonthlyStats = {
 export type CategoryStats = {
   categoryName: string;
   count: number;
+  currency: string;
   expense: number;
   income: number;
   kind: TransactionKind;
diff --git a/app/src/features/create-transaction/ui/CreateTransactionModal.tsx b/app/src/features/create-transaction/ui/CreateTransactionModal.tsx
index 55c96d9..ba8c9ad 100644
--- a/app/src/features/create-transaction/ui/CreateTransactionModal.tsx
+++ b/app/src/features/create-transaction/ui/CreateTransactionModal.tsx
@@ -1,12 +1,13 @@
 import { useState } from 'react';
 
-import type { CurrencyCode } from '@entities/app-settings';
 import type { Category } from '@entities/category';
 import type { Container } from '@entities/container';
 import type { Transaction } from '@entities/transaction';
 import { CategoryCombobox } from '@features/manage-categories';
 import { ContainerCombobox } from '@features/manage-containers';
+import { CurrencySelect } from '@features/manage-currencies';
 import { Button } from '@shared/ui/button';
+import { DatePicker } from '@shared/ui/date-picker';
 import { Input } from '@shared/ui/input';
 import { localStorageService } from '@shared/lib/storage/local-storage.service';
 import { Modal } from '@shared/ui/modal';
@@ -133,7 +134,7 @@ export function CreateTransactionModal({
       ? {
           color: '#6366f1',
           createdAt: initialTransaction.createdAt,
-          currency: initialTransaction.currency as CurrencyCode,
+          currency: initialTransaction.currency,
           icon: 'wallet',
           id: initialTransaction.containerId,
           isDefault: false,
@@ -224,40 +225,34 @@ export function CreateTransactionModal({
         <Select
           id="transaction-kind"
           label="Type"
-          onChange={(event) => {
-            const nextKind = event.target.value as 'income' | 'expense';
+          onChange={(nextKind) => {
+            const kind = nextKind as 'income' | 'expense';
 
             setValues({
               ...values,
-              categoryId: selectedCategory?.kind === nextKind ? values.categoryId : '',
-              categoryName: selectedCategory?.kind === nextKind ? values.categoryName : '',
-              kind: nextKind,
+              categoryId: selectedCategory?.kind === kind ? values.categoryId : '',
+              categoryName: selectedCategory?.kind === kind ? values.categoryName : '',
+              kind,
             });
             setSelectedCategory((currentCategory) =>
-              currentCategory?.kind === nextKind ? currentCategory : null,
+              currentCategory?.kind === kind ? currentCategory : null,
             );
           }}
+          options={[
+            { label: 'Expense', value: 'expense' },
+            { label: 'Income', value: 'income' },
+          ]}
           value={values.kind}
-        >
-          <option value="expense">Expense</option>
-          <option value="income">Income</option>
-        </Select>
+        />
         <div className="grid gap-4 md:grid-cols-2">
-          <Input
+          <DatePicker
             id="transaction-date"
             label="Date"
-            onChange={(event) => setValues({ ...values, date: event.target.value })}
-            type="date"
+            onChange={(date) => setValues({ ...values, date })}
             value={values.date}
           />
-          <Input
-            id="transaction-currency"
-            label="Currency"
-            maxLength={3}
-            onChange={(event) =>
-              setValues({ ...values, currency: event.target.value.toUpperCase() })
-            }
-            placeholder="UAH"
+          <CurrencySelect
+            onChange={(currency) => setValues({ ...values, currency })}
             value={values.currency}
           />
         </div>
@@ -284,7 +279,7 @@ export function CreateTransactionModal({
         <CategoryCombobox kind={values.kind} onChange={selectCategory} value={selectedCategory} />
         {containersEnabled ? (
           <ContainerCombobox
-            currency={values.currency as CurrencyCode}
+            currency={values.currency}
             onChange={selectContainer}
             value={selectedContainer}
           />
@@ -303,11 +298,16 @@ export function CreateTransactionModal({
           placeholder="Optional note"
           value={values.comment}
         />
-        <div className="flex justify-end gap-2">
-          <Button disabled={isCreating} onClick={onClose} variant="ghost">
+        <div className="flex flex-col-reverse gap-2 sm:flex-row sm:justify-end">
+          <Button
+            className="w-full sm:w-auto"
+            disabled={isCreating}
+            onClick={onClose}
+            variant="ghost"
+          >
             Cancel
           </Button>
-          <Button isLoading={isCreating} type="submit">
+          <Button className="w-full sm:w-auto" isLoading={isCreating} type="submit">
             {mode === 'edit' ? 'Save transaction' : 'Create transaction'}
           </Button>
         </div>
diff --git a/app/src/features/filter-transactions/index.ts b/app/src/features/filter-transactions/index.ts
index c09be1c..fd83d57 100644
--- a/app/src/features/filter-transactions/index.ts
+++ b/app/src/features/filter-transactions/index.ts
@@ -3,5 +3,6 @@ export {
   filterTransactions,
   getTransactionContainerOptions,
   getTransactionCategoryOptions,
+  getTransactionCurrencyOptions,
 } from './lib/transaction-filters';
 export type { TransactionFilters, TransactionKindFilter } from './types/transaction-filters.type';
diff --git a/app/src/features/filter-transactions/lib/transaction-filters.test.ts b/app/src/features/filter-transactions/lib/transaction-filters.test.ts
index 84e8999..e0e5ef8 100644
--- a/app/src/features/filter-transactions/lib/transaction-filters.test.ts
+++ b/app/src/features/filter-transactions/lib/transaction-filters.test.ts
@@ -6,6 +6,7 @@ import {
   createDefaultTransactionFilters,
   filterTransactions,
   getTransactionCategoryOptions,
+  getTransactionCurrencyOptions,
 } from './transaction-filters';
 
 function createTransaction(overrides: Partial<Transaction>): Transaction {
@@ -177,3 +178,68 @@ describe('getTransactionCategoryOptions', () => {
     ).toEqual(['Food', 'Salary', 'Transport']);
   });
 });
+
+describe('filterTransactions currency filter', () => {
+  const multiCurrencyTransactions = [
+    createTransaction({ id: 'uah-1', currency: 'UAH' }),
+    createTransaction({ id: 'usd-1', currency: 'USD' }),
+    createTransaction({ id: 'eur-1', currency: 'EUR' }),
+    createTransaction({ id: 'uah-2', currency: 'UAH' }),
+  ];
+
+  it('shows all currencies when filter is empty', () => {
+    expect(
+      filterTransactions(multiCurrencyTransactions, createDefaultTransactionFilters()).map(
+        (transaction) => transaction.id,
+      ),
+    ).toEqual(['uah-1', 'usd-1', 'eur-1', 'uah-2']);
+  });
+
+  it('shows only UAH transactions', () => {
+    expect(
+      filterTransactions(multiCurrencyTransactions, {
+        ...createDefaultTransactionFilters(),
+        currency: 'UAH',
+      }).map((transaction) => transaction.id),
+    ).toEqual(['uah-1', 'uah-2']);
+  });
+
+  it('shows only USD transactions', () => {
+    expect(
+      filterTransactions(multiCurrencyTransactions, {
+        ...createDefaultTransactionFilters(),
+        currency: 'USD',
+      }).map((transaction) => transaction.id),
+    ).toEqual(['usd-1']);
+  });
+
+  it('does not break other active filters', () => {
+    expect(
+      filterTransactions(
+        [
+          ...multiCurrencyTransactions,
+          createTransaction({
+            id: 'uah-income',
+            currency: 'UAH',
+            kind: 'income',
+            signedAmount: 500,
+          }),
+        ],
+        { ...createDefaultTransactionFilters(), currency: 'UAH', kind: 'income' },
+      ).map((transaction) => transaction.id),
+    ).toEqual(['uah-income']);
+  });
+});
+
+describe('getTransactionCurrencyOptions', () => {
+  it('dedupes and sorts currencies', () => {
+    expect(
+      getTransactionCurrencyOptions([
+        createTransaction({ currency: 'USD', id: 'usd-1' }),
+        createTransaction({ currency: 'UAH', id: 'uah-1' }),
+        createTransaction({ currency: 'EUR', id: 'eur-1' }),
+        createTransaction({ currency: 'UAH', id: 'uah-2' }),
+      ]),
+    ).toEqual(['EUR', 'UAH', 'USD']);
+  });
+});
diff --git a/app/src/features/filter-transactions/lib/transaction-filters.ts b/app/src/features/filter-transactions/lib/transaction-filters.ts
index 0aa88ef..2c19fb4 100644
--- a/app/src/features/filter-transactions/lib/transaction-filters.ts
+++ b/app/src/features/filter-transactions/lib/transaction-filters.ts
@@ -8,6 +8,7 @@ export function createDefaultTransactionFilters(): TransactionFilters {
     amountTo: '',
     category: '',
     container: '',
+    currency: '',
     dateFrom: '',
     dateTo: '',
     kind: 'all',
@@ -93,6 +94,10 @@ export function filterTransactions(
       return false;
     }
 
+    if (filters.currency && transaction.currency !== filters.currency) {
+      return false;
+    }
+
     return matchesQuery(transaction, filters.query);
   });
 }
@@ -108,3 +113,9 @@ export function getTransactionContainerOptions(transactions: Transaction[]) {
     .filter((containerName): containerName is string => Boolean(containerName))
     .sort((left, right) => left.localeCompare(right));
 }
+
+export function getTransactionCurrencyOptions(transactions: Transaction[]) {
+  return [...new Set(transactions.map((transaction) => transaction.currency))]
+    .filter(Boolean)
+    .sort((left, right) => left.localeCompare(right));
+}
diff --git a/app/src/features/filter-transactions/types/transaction-filters.type.ts b/app/src/features/filter-transactions/types/transaction-filters.type.ts
index ae5b9c5..e6850ab 100644
--- a/app/src/features/filter-transactions/types/transaction-filters.type.ts
+++ b/app/src/features/filter-transactions/types/transaction-filters.type.ts
@@ -7,6 +7,7 @@ export type TransactionFilters = {
   amountTo: string;
   category: string;
   container: string;
+  currency: string;
   dateFrom: string;
   dateTo: string;
   kind: TransactionKindFilter;
diff --git a/app/src/features/manage-categories/lib/manage-categories.service.ts b/app/src/features/manage-categories/lib/manage-categories.service.ts
index f543ca4..a825d41 100644
--- a/app/src/features/manage-categories/lib/manage-categories.service.ts
+++ b/app/src/features/manage-categories/lib/manage-categories.service.ts
@@ -76,7 +76,7 @@ export async function readCategories({
       range: sheetRanges.categoriesData,
       spreadsheetId,
     });
-    const remoteCategories = valueRange.values
+    const remoteCategories = (valueRange.values ?? [])
       .map(mapRowToCategory)
       .filter((category) => category !== null);
 
diff --git a/app/src/features/manage-containers/lib/container-row.mapper.ts b/app/src/features/manage-containers/lib/container-row.mapper.ts
index 76c0318..80b82f5 100644
--- a/app/src/features/manage-containers/lib/container-row.mapper.ts
+++ b/app/src/features/manage-containers/lib/container-row.mapper.ts
@@ -1,4 +1,3 @@
-import type { CurrencyCode } from '@entities/app-settings';
 import type { Container } from '@entities/container';
 
 export function mapContainerToRow(container: Container): string[] {
@@ -23,7 +22,7 @@ export function mapRowToContainer(row: string[]): Container | null {
   return {
     color: color || '#6366f1',
     createdAt,
-    currency: currency.toUpperCase() as CurrencyCode,
+    currency: currency.toUpperCase(),
     icon: icon || 'wallet',
     id,
     isDefault: isDefault === 'TRUE',
diff --git a/app/src/features/manage-containers/lib/manage-containers.service.ts b/app/src/features/manage-containers/lib/manage-containers.service.ts
index 3047a51..b783a71 100644
--- a/app/src/features/manage-containers/lib/manage-containers.service.ts
+++ b/app/src/features/manage-containers/lib/manage-containers.service.ts
@@ -77,7 +77,7 @@ export async function readContainers({
       range: sheetRanges.containersData,
       spreadsheetId,
     });
-    const remoteContainers = valueRange.values
+    const remoteContainers = (valueRange.values ?? [])
       .map(mapRowToContainer)
       .filter((container) => container !== null);
 
diff --git a/app/src/features/manage-containers/ui/ManageContainersModal.tsx b/app/src/features/manage-containers/ui/ManageContainersModal.tsx
index bbdf0c4..996aa64 100644
--- a/app/src/features/manage-containers/ui/ManageContainersModal.tsx
+++ b/app/src/features/manage-containers/ui/ManageContainersModal.tsx
@@ -1,10 +1,10 @@
 import { useState } from 'react';
 
-import type { CurrencyCode } from '@entities/app-settings';
 import { Badge } from '@shared/ui/badge';
 import { Button } from '@shared/ui/button';
 import { Input } from '@shared/ui/input';
 import { Modal } from '@shared/ui/modal';
+import { CurrencySelect } from '@features/manage-currencies';
 
 import { useContainers } from '../model/useContainers';
 
@@ -17,7 +17,7 @@ export function ManageContainersModal({ isOpen, onClose }: ManageContainersModal
   const { containers, createAndSelectContainer, error, isCreating, isLoading, warning } =
     useContainers();
   const [name, setName] = useState('');
-  const [currency, setCurrency] = useState<CurrencyCode>('UAH');
+  const [currency, setCurrency] = useState('UAH');
 
   async function submitContainer() {
     if (!name.trim()) {
@@ -52,13 +52,7 @@ export function ManageContainersModal({ isOpen, onClose }: ManageContainersModal
             placeholder="Cash, Savings, EUR card"
             value={name}
           />
-          <Input
-            id="container-currency"
-            label="Currency"
-            maxLength={3}
-            onChange={(event) => setCurrency(event.target.value.toUpperCase() as CurrencyCode)}
-            value={currency}
-          />
+          <CurrencySelect onChange={setCurrency} value={currency} />
           <Button isLoading={isCreating} onClick={() => void submitContainer()}>
             Add
           </Button>
diff --git a/app/src/features/manage-currencies/index.ts b/app/src/features/manage-currencies/index.ts
new file mode 100644
index 0000000..98c6a09
--- /dev/null
+++ b/app/src/features/manage-currencies/index.ts
@@ -0,0 +1,10 @@
+export { formatCurrencyLabel, getEnabledCurrencies } from './lib/currency-options';
+export { mapCurrencyToRow, mapRowToCurrency } from './lib/currency-row.mapper';
+export { readCurrencies } from './lib/manage-currencies.service';
+export { useCurrencies } from './model/useCurrencies';
+export { CurrencySelect } from './ui/CurrencySelect';
+export type {
+  CurrenciesTemplateStatus,
+  ReadCurrenciesContext,
+  ReadCurrenciesResult,
+} from './lib/manage-currencies.service';
diff --git a/app/src/features/manage-currencies/lib/currency-options.test.ts b/app/src/features/manage-currencies/lib/currency-options.test.ts
new file mode 100644
index 0000000..dc1a935
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/currency-options.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Currency } from '@entities/currency';
+
+import { formatCurrencyLabel, getEnabledCurrencies } from './currency-options';
+
+function makeCurrency(overrides: Partial<Currency>): Currency {
+  return {
+    id: 'usd',
+    code: 'USD',
+    name: 'US Dollar',
+    symbol: '$',
+    decimalDigits: 2,
+    isDefault: false,
+    isEnabled: true,
+    ...overrides,
+  };
+}
+
+describe('getEnabledCurrencies', () => {
+  it('keeps only enabled currencies', () => {
+    const currencies = [
+      makeCurrency({ id: 'usd', code: 'USD', isEnabled: true }),
+      makeCurrency({ id: 'rub', code: 'RUB', isEnabled: false }),
+    ];
+
+    expect(getEnabledCurrencies(currencies).map((currency) => currency.code)).toEqual(['USD']);
+  });
+});
+
+describe('formatCurrencyLabel', () => {
+  it('shows code and symbol', () => {
+    expect(formatCurrencyLabel({ code: 'UAH', symbol: '₴' })).toBe('UAH ₴');
+  });
+
+  it('shows code only when symbol duplicates or is empty', () => {
+    expect(formatCurrencyLabel({ code: 'CHF', symbol: 'CHF' })).toBe('CHF');
+    expect(formatCurrencyLabel({ code: 'XXX', symbol: '' })).toBe('XXX');
+  });
+});
diff --git a/app/src/features/manage-currencies/lib/currency-options.ts b/app/src/features/manage-currencies/lib/currency-options.ts
new file mode 100644
index 0000000..728bfce
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/currency-options.ts
@@ -0,0 +1,11 @@
+import type { Currency } from '@entities/currency';
+
+export function getEnabledCurrencies(currencies: Currency[]): Currency[] {
+  return currencies.filter((currency) => currency.isEnabled);
+}
+
+export function formatCurrencyLabel(currency: Pick<Currency, 'code' | 'symbol'>): string {
+  const symbol = currency.symbol.trim();
+
+  return symbol && symbol !== currency.code ? `${currency.code} ${symbol}` : currency.code;
+}
diff --git a/app/src/features/manage-currencies/lib/currency-row.mapper.test.ts b/app/src/features/manage-currencies/lib/currency-row.mapper.test.ts
new file mode 100644
index 0000000..cf9f045
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/currency-row.mapper.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Currency } from '@entities/currency';
+
+import { mapCurrencyToRow, mapRowToCurrency } from './currency-row.mapper';
+
+const currency: Currency = {
+  id: 'uah',
+  code: 'UAH',
+  name: 'Ukrainian Hryvnia',
+  symbol: '₴',
+  decimalDigits: 2,
+  isDefault: true,
+  isEnabled: true,
+};
+
+describe('currency row mapper', () => {
+  it('maps currency to Google Sheets row', () => {
+    expect(mapCurrencyToRow(currency)).toEqual([
+      'uah',
+      'UAH',
+      'Ukrainian Hryvnia',
+      '₴',
+      '2',
+      'TRUE',
+      'TRUE',
+    ]);
+  });
+
+  it('maps row to currency', () => {
+    expect(mapRowToCurrency(['uah', 'UAH', 'Ukrainian Hryvnia', '₴', '2', 'TRUE', 'TRUE'])).toEqual(
+      currency,
+    );
+  });
+
+  it('parses lowercase booleans and uppercases the code', () => {
+    expect(mapRowToCurrency(['eur', 'eur', 'Euro', '€', '2', 'true', 'false'])).toEqual({
+      id: 'eur',
+      code: 'EUR',
+      name: 'Euro',
+      symbol: '€',
+      decimalDigits: 2,
+      isDefault: true,
+      isEnabled: false,
+    });
+  });
+
+  it('treats blank flags as not default but enabled so hand-added rows show up', () => {
+    expect(mapRowToCurrency(['gbp', 'GBP', 'British Pound', '£', '', '', ''])).toEqual({
+      id: 'gbp',
+      code: 'GBP',
+      name: 'British Pound',
+      symbol: '£',
+      decimalDigits: 2,
+      isDefault: false,
+      isEnabled: true,
+    });
+  });
+
+  it('falls back to code for missing name and symbol', () => {
+    expect(mapRowToCurrency(['czk', 'czk', '', '', 'x', 'FALSE', 'TRUE'])).toEqual({
+      id: 'czk',
+      code: 'CZK',
+      name: 'CZK',
+      symbol: 'CZK',
+      decimalDigits: 2,
+      isDefault: false,
+      isEnabled: true,
+    });
+  });
+
+  it('returns null for rows without an id or code', () => {
+    expect(mapRowToCurrency(['', 'UAH'])).toBeNull();
+    expect(mapRowToCurrency(['uah', ''])).toBeNull();
+  });
+});
diff --git a/app/src/features/manage-currencies/lib/currency-row.mapper.ts b/app/src/features/manage-currencies/lib/currency-row.mapper.ts
new file mode 100644
index 0000000..fa1e99f
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/currency-row.mapper.ts
@@ -0,0 +1,51 @@
+import type { Currency } from '@entities/currency';
+
+function parseSheetBoolean(value: string | undefined, fallback: boolean): boolean {
+  if (value === undefined || value.trim() === '') {
+    return fallback;
+  }
+
+  return ['true', '1', 'yes'].includes(value.trim().toLowerCase());
+}
+
+function parseDecimalDigits(value: string | undefined): number {
+  if (value === undefined || value.trim() === '') {
+    return 2;
+  }
+
+  const parsed = Number(value);
+
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 2;
+}
+
+export function mapCurrencyToRow(currency: Currency): string[] {
+  return [
+    currency.id,
+    currency.code,
+    currency.name,
+    currency.symbol,
+    String(currency.decimalDigits),
+    currency.isDefault ? 'TRUE' : 'FALSE',
+    currency.isEnabled ? 'TRUE' : 'FALSE',
+  ];
+}
+
+export function mapRowToCurrency(row: string[]): Currency | null {
+  const [id, code, name, symbol, decimalDigits, isDefault, isEnabled] = row;
+
+  if (!id || !code) {
+    return null;
+  }
+
+  const normalizedCode = code.trim().toUpperCase();
+
+  return {
+    id: id.trim(),
+    code: normalizedCode,
+    name: name?.trim() || normalizedCode,
+    symbol: symbol?.trim() || normalizedCode,
+    decimalDigits: parseDecimalDigits(decimalDigits),
+    isDefault: parseSheetBoolean(isDefault, false),
+    isEnabled: parseSheetBoolean(isEnabled, true),
+  };
+}
diff --git a/app/src/features/manage-currencies/lib/manage-currencies.service.test.ts b/app/src/features/manage-currencies/lib/manage-currencies.service.test.ts
new file mode 100644
index 0000000..a614f1c
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/manage-currencies.service.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { readCurrencies } from './manage-currencies.service';
+
+const metadataWithCurrencies = {
+  spreadsheetId: 'sheet-id',
+  sheets: [
+    {
+      properties: {
+        title: 'Currencies',
+      },
+    },
+  ],
+};
+
+describe('manage currencies service', () => {
+  it('returns default currencies without Google context', async () => {
+    await expect(readCurrencies({ accessToken: null, spreadsheetId: null })).resolves.toEqual({
+      currencies: expect.arrayContaining([
+        expect.objectContaining({ code: 'UAH' }),
+        expect.objectContaining({ code: 'USD' }),
+      ]),
+      templateStatus: 'unknown',
+      warning: null,
+    });
+  });
+
+  it('reads currencies from Google Sheets rows including disabled ones', async () => {
+    const getSpreadsheetMetadata = vi.fn().mockResolvedValue(metadataWithCurrencies);
+    const readRange = vi.fn().mockResolvedValue({
+      values: [
+        ['uah', 'UAH', 'Ukrainian Hryvnia', '₴', '2', 'TRUE', 'TRUE'],
+        ['rub', 'RUB', 'Russian Ruble', '₽', '2', 'TRUE', 'FALSE'],
+      ],
+    });
+
+    await expect(
+      readCurrencies({
+        accessToken: 'token',
+        googleSheetsClient: { getSpreadsheetMetadata, readRange },
+        spreadsheetId: 'sheet-id',
+      }),
+    ).resolves.toEqual({
+      currencies: [
+        {
+          id: 'uah',
+          code: 'UAH',
+          name: 'Ukrainian Hryvnia',
+          symbol: '₴',
+          decimalDigits: 2,
+          isDefault: true,
+          isEnabled: true,
+        },
+        {
+          id: 'rub',
+          code: 'RUB',
+          name: 'Russian Ruble',
+          symbol: '₽',
+          decimalDigits: 2,
+          isDefault: true,
+          isEnabled: false,
+        },
+      ],
+      templateStatus: 'ready',
+      warning: null,
+    });
+  });
+
+  it('falls back to defaults without reading values when Currencies sheet is missing', async () => {
+    const getSpreadsheetMetadata = vi.fn().mockResolvedValue({
+      spreadsheetId: 'sheet-id',
+      sheets: [{ properties: { title: 'Ledger' } }],
+    });
+    const readRange = vi.fn();
+
+    const result = await readCurrencies({
+      accessToken: 'token',
+      googleSheetsClient: { getSpreadsheetMetadata, readRange },
+      spreadsheetId: 'sheet-id',
+    });
+
+    expect(result.templateStatus).toBe('needs-setup');
+    expect(result.warning).toContain('Spreadsheet template is not ready');
+    expect(result.currencies).toEqual(
+      expect.arrayContaining([expect.objectContaining({ code: 'UAH' })]),
+    );
+    expect(readRange).not.toHaveBeenCalled();
+  });
+
+  it('falls back to defaults when the sheet has no rows', async () => {
+    const getSpreadsheetMetadata = vi.fn().mockResolvedValue(metadataWithCurrencies);
+    const readRange = vi.fn().mockResolvedValue({ values: [] });
+
+    const result = await readCurrencies({
+      accessToken: 'token',
+      googleSheetsClient: { getSpreadsheetMetadata, readRange },
+      spreadsheetId: 'sheet-id',
+    });
+
+    expect(result.templateStatus).toBe('ready');
+    expect(result.currencies.length).toBeGreaterThan(0);
+  });
+});
diff --git a/app/src/features/manage-currencies/lib/manage-currencies.service.ts b/app/src/features/manage-currencies/lib/manage-currencies.service.ts
new file mode 100644
index 0000000..d899a9a
--- /dev/null
+++ b/app/src/features/manage-currencies/lib/manage-currencies.service.ts
@@ -0,0 +1,91 @@
+import { getDefaultCurrencies, type Currency } from '@entities/currency';
+import {
+  createGoogleSheetsClient,
+  GoogleSheetsApiError,
+  type GoogleSheetsClient,
+} from '@shared/api/google-sheets';
+import { sheetNames, sheetRanges } from '@shared/config/constants/sheet.constants';
+
+import { mapRowToCurrency } from './currency-row.mapper';
+
+export type CurrenciesTemplateStatus = 'ready' | 'needs-setup' | 'unknown';
+
+export type ReadCurrenciesContext = {
+  accessToken: string | null;
+  googleSheetsClient?: Pick<GoogleSheetsClient, 'getSpreadsheetMetadata' | 'readRange'>;
+  spreadsheetId: string | null;
+};
+
+export type ReadCurrenciesResult = {
+  currencies: Currency[];
+  templateStatus: CurrenciesTemplateStatus;
+  warning: string | null;
+};
+
+const templateNotReadyMessage =
+  'Spreadsheet template is not ready. Open Settings and run setup to load currencies.';
+
+function hasCurrenciesSheet(
+  metadata: Awaited<ReturnType<GoogleSheetsClient['getSpreadsheetMetadata']>>,
+) {
+  return Boolean(
+    metadata.sheets?.some((sheet) => sheet.properties?.title === sheetNames.currencies),
+  );
+}
+
+export async function readCurrencies({
+  accessToken,
+  googleSheetsClient = createGoogleSheetsClient(),
+  spreadsheetId,
+}: ReadCurrenciesContext): Promise<ReadCurrenciesResult> {
+  if (!accessToken || !spreadsheetId) {
+    return {
+      currencies: getDefaultCurrencies(),
+      templateStatus: 'unknown',
+      warning: null,
+    };
+  }
+
+  const metadata = await googleSheetsClient.getSpreadsheetMetadata({
+    accessToken,
+    spreadsheetId,
+  });
+
+  if (!hasCurrenciesSheet(metadata)) {
+    return {
+      currencies: getDefaultCurrencies(),
+      templateStatus: 'needs-setup',
+      warning: templateNotReadyMessage,
+    };
+  }
+
+  try {
+    const valueRange = await googleSheetsClient.readRange({
+      accessToken,
+      range: sheetRanges.currenciesData,
+      spreadsheetId,
+    });
+    const remoteCurrencies = (valueRange.values ?? [])
+      .map(mapRowToCurrency)
+      .filter((currency): currency is Currency => currency !== null);
+
+    return {
+      currencies: remoteCurrencies.length ? remoteCurrencies : getDefaultCurrencies(),
+      templateStatus: 'ready',
+      warning: null,
+    };
+  } catch (error) {
+    if (
+      error instanceof GoogleSheetsApiError &&
+      ['template-not-ready', 'unknown'].includes(error.code)
+    ) {
+      return {
+        currencies: getDefaultCurrencies(),
+        templateStatus: 'needs-setup',
+        warning: templateNotReadyMessage,
+      };
+    }
+
+    throw error;
+  }
+}
diff --git a/app/src/features/manage-currencies/model/useCurrencies.ts b/app/src/features/manage-currencies/model/useCurrencies.ts
new file mode 100644
index 0000000..bfe9d48
--- /dev/null
+++ b/app/src/features/manage-currencies/model/useCurrencies.ts
@@ -0,0 +1,66 @@
+import { useEffect, useState } from 'react';
+
+import { getDefaultCurrencies, type Currency } from '@entities/currency';
+import { useGoogleAuth } from '@features/google-auth';
+import { localStorageService } from '@shared/lib/storage/local-storage.service';
+
+import { type CurrenciesTemplateStatus, readCurrencies } from '../lib/manage-currencies.service';
+
+export function useCurrencies() {
+  const googleAuth = useGoogleAuth();
+  const spreadsheetId = localStorageService.get('spreadsheetId');
+  const [currencies, setCurrencies] = useState<Currency[]>(getDefaultCurrencies);
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [templateStatus, setTemplateStatus] = useState<CurrenciesTemplateStatus>('unknown');
+  const [warning, setWarning] = useState<string | null>(null);
+
+  useEffect(() => {
+    let isActive = true;
+
+    async function loadCurrencies() {
+      setIsLoading(true);
+      setError(null);
+      setWarning(null);
+
+      try {
+        const result = await readCurrencies({
+          accessToken: googleAuth.accessToken,
+          spreadsheetId,
+        });
+
+        if (isActive) {
+          setCurrencies(result.currencies);
+          setTemplateStatus(result.templateStatus);
+          setWarning(result.warning);
+        }
+      } catch (caughtError) {
+        if (isActive) {
+          setTemplateStatus('unknown');
+          setCurrencies(getDefaultCurrencies());
+          setError(
+            caughtError instanceof Error ? caughtError.message : 'Could not load currencies.',
+          );
+        }
+      } finally {
+        if (isActive) {
+          setIsLoading(false);
+        }
+      }
+    }
+
+    void loadCurrencies();
+
+    return () => {
+      isActive = false;
+    };
+  }, [googleAuth.accessToken, spreadsheetId]);
+
+  return {
+    currencies,
+    error,
+    isLoading,
+    templateStatus,
+    warning,
+  };
+}
diff --git a/app/src/features/manage-currencies/ui/CurrencySelect.tsx b/app/src/features/manage-currencies/ui/CurrencySelect.tsx
new file mode 100644
index 0000000..d7700a3
--- /dev/null
+++ b/app/src/features/manage-currencies/ui/CurrencySelect.tsx
@@ -0,0 +1,61 @@
+import { useMemo } from 'react';
+
+import type { Currency } from '@entities/currency';
+import { Select } from '@shared/ui/select';
+
+import { formatCurrencyLabel, getEnabledCurrencies } from '../lib/currency-options';
+import { useCurrencies } from '../model/useCurrencies';
+
+type CurrencySelectProps = {
+  id?: string;
+  label?: string;
+  onChange: (code: string) => void;
+  value: string;
+};
+
+function buildUnknownCurrency(code: string): Currency {
+  return {
+    id: code.toLowerCase(),
+    code,
+    name: code,
+    symbol: '',
+    decimalDigits: 2,
+    isDefault: false,
+    isEnabled: true,
+  };
+}
+
+export function CurrencySelect({
+  id = 'transaction-currency',
+  label = 'Currency',
+  onChange,
+  value,
+}: CurrencySelectProps) {
+  const { currencies, isLoading, warning } = useCurrencies();
+
+  const options = useMemo(() => {
+    const enabled = getEnabledCurrencies(currencies);
+
+    // Keep a legacy/disabled currency selectable so editing an older transaction
+    // never silently rewrites its currency to a different option.
+    if (value && !enabled.some((currency) => currency.code === value)) {
+      return [buildUnknownCurrency(value), ...enabled];
+    }
+
+    return enabled;
+  }, [currencies, value]);
+
+  return (
+    <Select
+      hint={warning ?? (isLoading ? 'Loading currencies...' : undefined)}
+      id={id}
+      label={label}
+      onChange={onChange}
+      options={options.map((currency) => ({
+        label: formatCurrencyLabel(currency),
+        value: currency.code,
+      }))}
+      value={value}
+    />
+  );
+}
diff --git a/app/src/features/manage-transactions/index.ts b/app/src/features/manage-transactions/index.ts
index 4ea9bb0..9a0a7cc 100644
--- a/app/src/features/manage-transactions/index.ts
+++ b/app/src/features/manage-transactions/index.ts
@@ -5,7 +5,7 @@ export {
   updateTransaction,
 } from './lib/manage-transactions.service';
 export { mapRowToTransaction, mapTransactionToRow } from './lib/transaction-row.mapper';
-export { calculateTransactionSummary, type TransactionSummary } from './lib/transaction-summary';
+export { calculateTransactionSummary, type CurrencySummary } from './lib/transaction-summary';
 export { useTransactions } from './model/useTransactions';
 export { useOfflineSyncStatus, type OfflineSyncStatus } from './model/useOfflineSyncStatus';
-export { offlineTransactionsStorage } from './lib/offline-transactions.storage';
+export { createOfflineTransactionsStorage } from './lib/offline-transactions.storage';
diff --git a/app/src/features/manage-transactions/lib/local-queue-data-source.test.ts b/app/src/features/manage-transactions/lib/local-queue-data-source.test.ts
index 8b3ef32..5b5ac9c 100644
--- a/app/src/features/manage-transactions/lib/local-queue-data-source.test.ts
+++ b/app/src/features/manage-transactions/lib/local-queue-data-source.test.ts
@@ -4,6 +4,11 @@ import type { Transaction } from '@entities/transaction';
 import { indexedDbService } from '@shared/lib/storage/indexed-db.service';
 
 import { createLocalQueueDataSource } from './local-queue-data-source';
+import { createOfflineTransactionsStorage } from './offline-transactions.storage';
+
+const TEST_SPREADSHEET_ID = 'test-sheet';
+const pendingQueueKey = `spreadsheet:${TEST_SPREADSHEET_ID}:pendingTransactionsQueue`;
+const failedQueueKey = `spreadsheet:${TEST_SPREADSHEET_ID}:failedSyncQueue`;
 
 const transaction: Transaction = {
   id: 'tx-1',
@@ -21,13 +26,17 @@ const transaction: Transaction = {
   syncStatus: 'pending',
 };
 
+function makeDataSource(remoteDataSource?: Parameters<typeof createLocalQueueDataSource>[0]) {
+  return createLocalQueueDataSource(remoteDataSource, TEST_SPREADSHEET_ID);
+}
+
 describe('local queue data source', () => {
   beforeEach(async () => {
     await indexedDbService.clear();
   });
 
   it('stores pending transactions in cache and queue', async () => {
-    const dataSource = createLocalQueueDataSource();
+    const dataSource = makeDataSource();
 
     await expect(dataSource.createTransaction(transaction)).resolves.toMatchObject({
       id: 'tx-1',
@@ -44,7 +53,7 @@ describe('local queue data source', () => {
   });
 
   it('merges create and update into one latest create queue item', async () => {
-    const dataSource = createLocalQueueDataSource();
+    const dataSource = makeDataSource();
 
     await dataSource.createTransaction(transaction);
     await dataSource.updateTransaction({
@@ -54,7 +63,7 @@ describe('local queue data source', () => {
       signedAmount: -300,
     });
 
-    await expect(indexedDbService.get('pendingTransactionsQueue')).resolves.toEqual([
+    await expect(indexedDbService.get(pendingQueueKey)).resolves.toEqual([
       expect.objectContaining({
         operation: 'create',
         transaction: expect.objectContaining({
@@ -67,12 +76,12 @@ describe('local queue data source', () => {
   });
 
   it('removes pending create from queue when transaction is deleted before sync', async () => {
-    const dataSource = createLocalQueueDataSource();
+    const dataSource = makeDataSource();
 
     await dataSource.createTransaction(transaction);
     await dataSource.softDeleteTransaction(transaction.id);
 
-    await expect(indexedDbService.get('pendingTransactionsQueue')).resolves.toEqual([]);
+    await expect(indexedDbService.get(pendingQueueKey)).resolves.toEqual([]);
     await expect(dataSource.getTransactions()).resolves.toEqual([
       expect.objectContaining({
         deletedAt: expect.any(String),
@@ -82,12 +91,12 @@ describe('local queue data source', () => {
   });
 
   it('replaces pending update with delete queue item', async () => {
-    const dataSource = createLocalQueueDataSource();
+    const dataSource = makeDataSource();
 
     await dataSource.updateTransaction(transaction);
     await dataSource.softDeleteTransaction(transaction.id);
 
-    await expect(indexedDbService.get('pendingTransactionsQueue')).resolves.toEqual([
+    await expect(indexedDbService.get(pendingQueueKey)).resolves.toEqual([
       expect.objectContaining({
         operation: 'delete',
         transactionId: 'tx-1',
@@ -108,7 +117,7 @@ describe('local queue data source', () => {
       syncPending: vi.fn(),
       updateTransaction: vi.fn(),
     };
-    const dataSource = createLocalQueueDataSource(remoteDataSource);
+    const dataSource = makeDataSource(remoteDataSource);
 
     await dataSource.createTransaction(transaction);
     await expect(dataSource.syncPending()).resolves.toEqual({
@@ -146,7 +155,7 @@ describe('local queue data source', () => {
       syncPending: vi.fn(),
       updateTransaction: vi.fn(),
     };
-    const dataSource = createLocalQueueDataSource(remoteDataSource);
+    const dataSource = makeDataSource(remoteDataSource);
 
     await dataSource.createTransaction(transaction);
     await expect(dataSource.syncPending()).resolves.toEqual({
@@ -166,7 +175,7 @@ describe('local queue data source', () => {
       syncPending: vi.fn(),
       updateTransaction: vi.fn(),
     };
-    const dataSource = createLocalQueueDataSource(remoteDataSource);
+    const dataSource = makeDataSource(remoteDataSource);
 
     await dataSource.createTransaction(transaction);
     await expect(dataSource.syncPending()).resolves.toEqual({
@@ -174,7 +183,7 @@ describe('local queue data source', () => {
       synced: 0,
       total: 1,
     });
-    await expect(indexedDbService.get('failedSyncQueue')).resolves.toEqual([
+    await expect(indexedDbService.get(failedQueueKey)).resolves.toEqual([
       expect.objectContaining({
         attempts: 1,
         lastError: 'Network failed',
@@ -186,11 +195,57 @@ describe('local queue data source', () => {
       synced: 0,
       total: 1,
     });
-    await expect(indexedDbService.get('failedSyncQueue')).resolves.toEqual([
+    await expect(indexedDbService.get(failedQueueKey)).resolves.toEqual([
       expect.objectContaining({
         attempts: 2,
         transactionId: 'tx-1',
       }),
     ]);
   });
+
+  it('keeps caches isolated between different spreadsheets', async () => {
+    const dsA = createLocalQueueDataSource(undefined, 'sheet-a');
+    const dsB = createLocalQueueDataSource(undefined, 'sheet-b');
+
+    await dsA.createTransaction({ ...transaction, id: 'tx-a' });
+    await dsB.createTransaction({ ...transaction, id: 'tx-b' });
+
+    await expect(dsA.getTransactions()).resolves.toEqual([expect.objectContaining({ id: 'tx-a' })]);
+    await expect(dsB.getTransactions()).resolves.toEqual([expect.objectContaining({ id: 'tx-b' })]);
+  });
+
+  it('pending queue from spreadsheet-a is not synced via spreadsheet-b data source', async () => {
+    const remoteDataSource = {
+      createTransaction: vi.fn().mockResolvedValue({
+        ...transaction,
+        source: 'google-sheets',
+        syncStatus: 'synced',
+      }),
+      getCategories: vi.fn(),
+      getTransactions: vi.fn().mockResolvedValue([]),
+      softDeleteTransaction: vi.fn(),
+      syncPending: vi.fn(),
+      updateTransaction: vi.fn(),
+    };
+    const dsA = createLocalQueueDataSource(undefined, 'sheet-a');
+    const dsB = createLocalQueueDataSource(remoteDataSource, 'sheet-b');
+
+    await dsA.createTransaction(transaction);
+
+    await expect(dsB.syncPending()).resolves.toEqual({ failed: 0, synced: 0, total: 0 });
+    expect(remoteDataSource.createTransaction).not.toHaveBeenCalled();
+
+    const storageA = createOfflineTransactionsStorage('sheet-a');
+    await expect(storageA.getPendingQueue()).resolves.toHaveLength(1);
+  });
+
+  it('switching to a new spreadsheet sees empty cache even when old one has data', async () => {
+    const storageOld = createOfflineTransactionsStorage('old-sheet');
+
+    await storageOld.cacheTransactions([{ ...transaction, id: 'old-tx' }]);
+
+    const storageNew = createOfflineTransactionsStorage('new-sheet');
+
+    await expect(storageNew.getCachedTransactions()).resolves.toEqual([]);
+  });
 });
diff --git a/app/src/features/manage-transactions/lib/local-queue-data-source.ts b/app/src/features/manage-transactions/lib/local-queue-data-source.ts
index 6e2ac8b..c3435c4 100644
--- a/app/src/features/manage-transactions/lib/local-queue-data-source.ts
+++ b/app/src/features/manage-transactions/lib/local-queue-data-source.ts
@@ -3,7 +3,7 @@ import type { Transaction } from '@entities/transaction';
 import { getDefaultCategories } from '@entities/category';
 import type { FinanceDataSource, SyncQueueOperation, SyncResult } from '@shared/lib/data-source';
 
-import { offlineTransactionsStorage } from './offline-transactions.storage';
+import { createOfflineTransactionsStorage } from './offline-transactions.storage';
 import type { TransactionQueueItem } from '../types/sync-queue.type';
 
 function createQueueItem(
@@ -39,15 +39,16 @@ function asSyncingTransaction(transaction: Transaction): Transaction {
 
 export function createLocalQueueDataSource(
   remoteDataSource?: FinanceDataSource,
+  spreadsheetId = '__unscoped__',
 ): FinanceDataSource {
+  const storage = createOfflineTransactionsStorage(spreadsheetId);
+
   return {
     async createTransaction(transaction: Transaction): Promise<Transaction> {
       const pendingTransaction = asPendingTransaction(transaction);
 
-      await offlineTransactionsStorage.upsertCachedTransaction(pendingTransaction);
-      await offlineTransactionsStorage.addQueueItem(
-        createQueueItem('create', transaction.id, pendingTransaction),
-      );
+      await storage.upsertCachedTransaction(pendingTransaction);
+      await storage.addQueueItem(createQueueItem('create', transaction.id, pendingTransaction));
 
       return pendingTransaction;
     },
@@ -55,11 +56,11 @@ export function createLocalQueueDataSource(
       return Promise.resolve(getDefaultCategories());
     },
     getTransactions() {
-      return offlineTransactionsStorage.getCachedTransactions();
+      return storage.getCachedTransactions();
     },
     async softDeleteTransaction(transactionId: string): Promise<void> {
-      const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
-      const pendingQueue = await offlineTransactionsStorage.getPendingQueue();
+      const cachedTransactions = await storage.getCachedTransactions();
+      const pendingQueue = await storage.getPendingQueue();
       const now = new Date().toISOString();
       const transaction = cachedTransactions.find(
         (cachedTransaction) => cachedTransaction.id === transactionId,
@@ -69,7 +70,7 @@ export function createLocalQueueDataSource(
       );
 
       if (transaction) {
-        await offlineTransactionsStorage.upsertCachedTransaction({
+        await storage.upsertCachedTransaction({
           ...transaction,
           deletedAt: now,
           syncStatus: 'pending',
@@ -78,15 +79,15 @@ export function createLocalQueueDataSource(
       }
 
       if (pendingCreate) {
-        await offlineTransactionsStorage.removeQueueItem(pendingCreate.id);
+        await storage.removeQueueItem(pendingCreate.id);
         return;
       }
 
-      await offlineTransactionsStorage.addQueueItem(createQueueItem('delete', transactionId));
+      await storage.addQueueItem(createQueueItem('delete', transactionId));
     },
     async syncPending(): Promise<SyncResult> {
-      const queue = await offlineTransactionsStorage.getPendingQueue();
-      const failedQueue = await offlineTransactionsStorage.getFailedQueue();
+      const queue = await storage.getPendingQueue();
+      const failedQueue = await storage.getFailedQueue();
       const syncQueue = [...queue, ...failedQueue];
       let synced = 0;
       let failed = 0;
@@ -102,9 +103,7 @@ export function createLocalQueueDataSource(
       for (const item of syncQueue) {
         try {
           if (item.transaction) {
-            await offlineTransactionsStorage.upsertCachedTransaction(
-              asSyncingTransaction(item.transaction),
-            );
+            await storage.upsertCachedTransaction(asSyncingTransaction(item.transaction));
           }
 
           if (item.operation === 'create' && item.transaction) {
@@ -121,7 +120,7 @@ export function createLocalQueueDataSource(
                 syncStatus: 'synced',
               }));
 
-            await offlineTransactionsStorage.upsertCachedTransaction(syncedTransaction);
+            await storage.upsertCachedTransaction(syncedTransaction);
           }
 
           if (item.operation === 'update' && item.transaction) {
@@ -131,23 +130,23 @@ export function createLocalQueueDataSource(
               syncStatus: 'synced',
             });
 
-            await offlineTransactionsStorage.upsertCachedTransaction(syncedTransaction);
+            await storage.upsertCachedTransaction(syncedTransaction);
           }
 
           if (item.operation === 'delete') {
             await remoteDataSource.softDeleteTransaction(item.transactionId);
           }
 
-          await offlineTransactionsStorage.removeQueueItem(item.id);
+          await storage.removeQueueItem(item.id);
           synced += 1;
         } catch (error) {
-          await offlineTransactionsStorage.markQueueItemFailed(item, error);
+          await storage.markQueueItemFailed(item, error);
           failed += 1;
         }
       }
 
       if (synced > 0) {
-        await offlineTransactionsStorage.setLastSuccessfulSyncAt(new Date().toISOString());
+        await storage.setLastSuccessfulSyncAt(new Date().toISOString());
       }
 
       return {
@@ -157,7 +156,7 @@ export function createLocalQueueDataSource(
       };
     },
     async updateTransaction(transaction: Transaction): Promise<Transaction> {
-      const pendingQueue = await offlineTransactionsStorage.getPendingQueue();
+      const pendingQueue = await storage.getPendingQueue();
       const pendingCreate = pendingQueue.find(
         (item) => item.transactionId === transaction.id && item.operation === 'create',
       );
@@ -166,8 +165,8 @@ export function createLocalQueueDataSource(
         updatedAt: new Date().toISOString(),
       };
 
-      await offlineTransactionsStorage.upsertCachedTransaction(pendingTransaction);
-      await offlineTransactionsStorage.addQueueItem(
+      await storage.upsertCachedTransaction(pendingTransaction);
+      await storage.addQueueItem(
         createQueueItem(pendingCreate ? 'create' : 'update', transaction.id, pendingTransaction),
       );
 
diff --git a/app/src/features/manage-transactions/lib/manage-transactions.service.ts b/app/src/features/manage-transactions/lib/manage-transactions.service.ts
index ad6322b..4e43a64 100644
--- a/app/src/features/manage-transactions/lib/manage-transactions.service.ts
+++ b/app/src/features/manage-transactions/lib/manage-transactions.service.ts
@@ -97,7 +97,7 @@ export async function readTransactions({
       spreadsheetId,
     });
 
-    return valueRange.values
+    return (valueRange.values ?? [])
       .map(mapRowToTransaction)
       .filter((transaction) => transaction !== null)
       .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
@@ -155,7 +155,7 @@ async function findTransactionRowIndex({
     range: sheetRanges.ledgerData,
     spreadsheetId,
   });
-  const rowIndex = valueRange.values.findIndex((row) => row[0] === transactionId);
+  const rowIndex = (valueRange.values ?? []).findIndex((row) => row[0] === transactionId);
 
   return rowIndex === -1 ? null : rowIndex + 2;
 }
@@ -231,13 +231,14 @@ export async function softDeleteTransaction({
       range: sheetRanges.ledgerData,
       spreadsheetId,
     });
-    const rowIndex = valueRange.values.findIndex((row) => row[0] === transactionId);
+    const rows = valueRange.values ?? [];
+    const rowIndex = rows.findIndex((row) => row[0] === transactionId);
 
     if (rowIndex === -1) {
       throw new Error('Transaction was not found in Ledger.');
     }
 
-    const transaction = mapRowToTransaction(valueRange.values[rowIndex]);
+    const transaction = mapRowToTransaction(rows[rowIndex]);
 
     if (!transaction) {
       throw new Error('Transaction row is invalid.');
diff --git a/app/src/features/manage-transactions/lib/offline-transactions.storage.ts b/app/src/features/manage-transactions/lib/offline-transactions.storage.ts
index b64a99e..8b9030d 100644
--- a/app/src/features/manage-transactions/lib/offline-transactions.storage.ts
+++ b/app/src/features/manage-transactions/lib/offline-transactions.storage.ts
@@ -3,13 +3,6 @@ import { indexedDbService } from '@shared/lib/storage/indexed-db.service';
 
 import type { TransactionQueueItem } from '../types/sync-queue.type';
 
-const storageKeys = {
-  failedQueue: 'failedSyncQueue',
-  lastSuccessfulSyncAt: 'lastSuccessfulSyncAt',
-  pendingQueue: 'pendingTransactionsQueue',
-  transactionsCache: 'transactionsCache',
-} as const;
-
 function sortTransactions(transactions: Transaction[]) {
   return [...transactions].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
@@ -55,132 +48,147 @@ function mergeQueueItem(
   };
 }
 
-export const offlineTransactionsStorage = {
-  async addQueueItem(item: TransactionQueueItem): Promise<void> {
-    await this.upsertQueueItem(item);
-  },
-  async upsertQueueItem(item: TransactionQueueItem): Promise<void> {
-    const queue = await this.getPendingQueue();
-    const failedQueue = await this.getFailedQueue();
-    const existingItem = [...queue, ...failedQueue].find(
-      (queueItem) => queueItem.transactionId === item.transactionId,
-    );
-    const mergedItem = mergeQueueItem(existingItem, item);
-    const nextQueue = queue.filter((queueItem) => queueItem.transactionId !== item.transactionId);
-    const nextFailedQueue = failedQueue.filter(
-      (queueItem) => queueItem.transactionId !== item.transactionId,
-    );
-
-    await indexedDbService.set(
-      storageKeys.pendingQueue,
-      mergedItem ? [...nextQueue, mergedItem] : nextQueue,
-    );
-    await indexedDbService.set(storageKeys.failedQueue, nextFailedQueue);
-  },
-  async cacheTransactions(transactions: Transaction[]): Promise<void> {
-    await indexedDbService.set(storageKeys.transactionsCache, sortTransactions(transactions));
-  },
-  async clearFailedQueue(): Promise<void> {
-    await indexedDbService.remove(storageKeys.failedQueue);
-  },
-  async getCachedTransactions(): Promise<Transaction[]> {
-    return (await indexedDbService.get<Transaction[]>(storageKeys.transactionsCache)) ?? [];
-  },
-  async getFailedQueue(): Promise<TransactionQueueItem[]> {
-    return (await indexedDbService.get<TransactionQueueItem[]>(storageKeys.failedQueue)) ?? [];
-  },
-  async getLastSuccessfulSyncAt(): Promise<string | null> {
-    return indexedDbService.get<string>(storageKeys.lastSuccessfulSyncAt);
-  },
-  async getPendingQueue(): Promise<TransactionQueueItem[]> {
-    return (await indexedDbService.get<TransactionQueueItem[]>(storageKeys.pendingQueue)) ?? [];
-  },
-  async getQueueItems(): Promise<TransactionQueueItem[]> {
-    const [pendingQueue, failedQueue] = await Promise.all([
-      this.getPendingQueue(),
-      this.getFailedQueue(),
-    ]);
-
-    return [...pendingQueue, ...failedQueue].sort((left, right) =>
-      right.createdAt.localeCompare(left.createdAt),
-    );
-  },
-  async getSyncDiagnostics() {
-    const [cachedTransactions, failedQueue, lastSuccessfulSyncAt, pendingQueue] = await Promise.all(
-      [
-        this.getCachedTransactions(),
-        this.getFailedQueue(),
-        this.getLastSuccessfulSyncAt(),
+export function createOfflineTransactionsStorage(spreadsheetId: string) {
+  const prefix = `spreadsheet:${spreadsheetId}:`;
+  const keys = {
+    failedQueue: `${prefix}failedSyncQueue`,
+    lastSuccessfulSyncAt: `${prefix}lastSuccessfulSyncAt`,
+    pendingQueue: `${prefix}pendingTransactionsQueue`,
+    transactionsCache: `${prefix}transactionsCache`,
+  };
+
+  const storage = {
+    async addQueueItem(item: TransactionQueueItem): Promise<void> {
+      await this.upsertQueueItem(item);
+    },
+    async upsertQueueItem(item: TransactionQueueItem): Promise<void> {
+      const queue = await this.getPendingQueue();
+      const failedQueue = await this.getFailedQueue();
+      const existingItem = [...queue, ...failedQueue].find(
+        (queueItem) => queueItem.transactionId === item.transactionId,
+      );
+      const mergedItem = mergeQueueItem(existingItem, item);
+      const nextQueue = queue.filter((queueItem) => queueItem.transactionId !== item.transactionId);
+      const nextFailedQueue = failedQueue.filter(
+        (queueItem) => queueItem.transactionId !== item.transactionId,
+      );
+
+      await indexedDbService.set(
+        keys.pendingQueue,
+        mergedItem ? [...nextQueue, mergedItem] : nextQueue,
+      );
+      await indexedDbService.set(keys.failedQueue, nextFailedQueue);
+    },
+    async cacheTransactions(transactions: Transaction[]): Promise<void> {
+      await indexedDbService.set(keys.transactionsCache, sortTransactions(transactions));
+    },
+    async clearFailedQueue(): Promise<void> {
+      await indexedDbService.remove(keys.failedQueue);
+    },
+    async getCachedTransactions(): Promise<Transaction[]> {
+      return (await indexedDbService.get<Transaction[]>(keys.transactionsCache)) ?? [];
+    },
+    async getFailedQueue(): Promise<TransactionQueueItem[]> {
+      return (await indexedDbService.get<TransactionQueueItem[]>(keys.failedQueue)) ?? [];
+    },
+    async getLastSuccessfulSyncAt(): Promise<string | null> {
+      return indexedDbService.get<string>(keys.lastSuccessfulSyncAt);
+    },
+    async getPendingQueue(): Promise<TransactionQueueItem[]> {
+      return (await indexedDbService.get<TransactionQueueItem[]>(keys.pendingQueue)) ?? [];
+    },
+    async getQueueItems(): Promise<TransactionQueueItem[]> {
+      const [pendingQueue, failedQueue] = await Promise.all([
         this.getPendingQueue(),
-      ],
-    );
+        this.getFailedQueue(),
+      ]);
+
+      return [...pendingQueue, ...failedQueue].sort((left, right) =>
+        right.createdAt.localeCompare(left.createdAt),
+      );
+    },
+    async getSyncDiagnostics() {
+      const [cachedTransactions, failedQueue, lastSuccessfulSyncAt, pendingQueue] =
+        await Promise.all([
+          this.getCachedTransactions(),
+          this.getFailedQueue(),
+          this.getLastSuccessfulSyncAt(),
+          this.getPendingQueue(),
+        ]);
+
+      return {
+        cachedTransactions: cachedTransactions.length,
+        failed: failedQueue.length,
+        lastError: failedQueue.at(-1)?.lastError ?? null,
+        lastSuccessfulSyncAt,
+        pending: pendingQueue.length,
+        totalQueued: pendingQueue.length + failedQueue.length,
+      };
+    },
+    async markQueueItemFailed(item: TransactionQueueItem, error: unknown): Promise<void> {
+      const failedQueue = await this.getFailedQueue();
+      const pendingQueue = await this.getPendingQueue();
+      const failedItem: TransactionQueueItem = {
+        ...item,
+        attempts: item.attempts + 1,
+        lastError: error instanceof Error ? error.message : 'Sync failed.',
+      };
+
+      await indexedDbService.set(
+        keys.pendingQueue,
+        pendingQueue.filter((queueItem) => queueItem.id !== item.id),
+      );
+      await indexedDbService.set(keys.failedQueue, [
+        ...failedQueue.filter((queueItem) => queueItem.id !== item.id),
+        failedItem,
+      ]);
+
+      if (item.transaction) {
+        await this.upsertCachedTransaction({
+          ...item.transaction,
+          source: 'offline-queue',
+          syncStatus: 'failed',
+        });
+      }
+    },
+    async resetOfflineData(): Promise<void> {
+      await Promise.all([
+        indexedDbService.remove(keys.failedQueue),
+        indexedDbService.remove(keys.lastSuccessfulSyncAt),
+        indexedDbService.remove(keys.pendingQueue),
+        indexedDbService.remove(keys.transactionsCache),
+      ]);
+    },
+    async removeQueueItem(itemId: string): Promise<void> {
+      const pendingQueue = await this.getPendingQueue();
+      const failedQueue = await this.getFailedQueue();
+
+      await indexedDbService.set(
+        keys.pendingQueue,
+        pendingQueue.filter((item) => item.id !== itemId),
+      );
+      await indexedDbService.set(
+        keys.failedQueue,
+        failedQueue.filter((item) => item.id !== itemId),
+      );
+    },
+    async setLastSuccessfulSyncAt(value: string): Promise<void> {
+      await indexedDbService.set(keys.lastSuccessfulSyncAt, value);
+    },
+    async upsertCachedTransaction(transaction: Transaction): Promise<void> {
+      const cachedTransactions = await this.getCachedTransactions();
+      const nextTransactions = [
+        transaction,
+        ...cachedTransactions.filter(
+          (cachedTransaction) => cachedTransaction.id !== transaction.id,
+        ),
+      ];
+
+      await this.cacheTransactions(nextTransactions);
+    },
+  };
 
-    return {
-      cachedTransactions: cachedTransactions.length,
-      failed: failedQueue.length,
-      lastError: failedQueue.at(-1)?.lastError ?? null,
-      lastSuccessfulSyncAt,
-      pending: pendingQueue.length,
-      totalQueued: pendingQueue.length + failedQueue.length,
-    };
-  },
-  async markQueueItemFailed(item: TransactionQueueItem, error: unknown): Promise<void> {
-    const failedQueue = await this.getFailedQueue();
-    const pendingQueue = await this.getPendingQueue();
-    const failedItem: TransactionQueueItem = {
-      ...item,
-      attempts: item.attempts + 1,
-      lastError: error instanceof Error ? error.message : 'Sync failed.',
-    };
+  return storage;
+}
 
-    await indexedDbService.set(
-      storageKeys.pendingQueue,
-      pendingQueue.filter((queueItem) => queueItem.id !== item.id),
-    );
-    await indexedDbService.set(storageKeys.failedQueue, [
-      ...failedQueue.filter((queueItem) => queueItem.id !== item.id),
-      failedItem,
-    ]);
-
-    if (item.transaction) {
-      await this.upsertCachedTransaction({
-        ...item.transaction,
-        source: 'offline-queue',
-        syncStatus: 'failed',
-      });
-    }
-  },
-  async resetOfflineData(): Promise<void> {
-    await Promise.all([
-      indexedDbService.remove(storageKeys.failedQueue),
-      indexedDbService.remove(storageKeys.lastSuccessfulSyncAt),
-      indexedDbService.remove(storageKeys.pendingQueue),
-      indexedDbService.remove(storageKeys.transactionsCache),
-    ]);
-  },
-  async removeQueueItem(itemId: string): Promise<void> {
-    const pendingQueue = await this.getPendingQueue();
-    const failedQueue = await this.getFailedQueue();
-
-    await indexedDbService.set(
-      storageKeys.pendingQueue,
-      pendingQueue.filter((item) => item.id !== itemId),
-    );
-    await indexedDbService.set(
-      storageKeys.failedQueue,
-      failedQueue.filter((item) => item.id !== itemId),
-    );
-  },
-  async setLastSuccessfulSyncAt(value: string): Promise<void> {
-    await indexedDbService.set(storageKeys.lastSuccessfulSyncAt, value);
-  },
-  async upsertCachedTransaction(transaction: Transaction): Promise<void> {
-    const cachedTransactions = await this.getCachedTransactions();
-    const nextTransactions = [
-      transaction,
-      ...cachedTransactions.filter((cachedTransaction) => cachedTransaction.id !== transaction.id),
-    ];
-
-    await this.cacheTransactions(nextTransactions);
-  },
-};
+export type OfflineTransactionsStorage = ReturnType<typeof createOfflineTransactionsStorage>;
diff --git a/app/src/features/manage-transactions/lib/transaction-row.mapper.test.ts b/app/src/features/manage-transactions/lib/transaction-row.mapper.test.ts
index c116c91..ffaad42 100644
--- a/app/src/features/manage-transactions/lib/transaction-row.mapper.test.ts
+++ b/app/src/features/manage-transactions/lib/transaction-row.mapper.test.ts
@@ -238,6 +238,40 @@ describe('transaction row mapper', () => {
     expect(rows.map(mapRowToTransaction).filter(Boolean)).toHaveLength(4);
   });
 
+  it('reads non-UAH currencies from Ledger rows', () => {
+    expect(
+      mapRowToTransaction([
+        'tx-usd',
+        '2026-05-19',
+        'income',
+        'Freelance',
+        '500',
+        '500',
+        'USD',
+        '',
+        '',
+        '2026-05-19T10:00:00.000Z',
+        'google-sheets',
+        'synced',
+      ]),
+    ).toMatchObject({ currency: 'USD', amount: 500 });
+
+    expect(
+      mapRowToTransaction([
+        'tx-eur',
+        '2026-05-19',
+        'expense',
+        'Food',
+        '30',
+        '-30',
+        'EUR',
+        '',
+        '',
+        '2026-05-19T10:00:00.000Z',
+      ]),
+    ).toMatchObject({ currency: 'EUR', amount: 30, signedAmount: -30 });
+  });
+
   it('skips invalid rows', () => {
     expect(mapRowToTransaction(['', '2026-05-19'])).toBeNull();
     expect(
diff --git a/app/src/features/manage-transactions/lib/transaction-summary.test.ts b/app/src/features/manage-transactions/lib/transaction-summary.test.ts
index 27a3295..fe73947 100644
--- a/app/src/features/manage-transactions/lib/transaction-summary.test.ts
+++ b/app/src/features/manage-transactions/lib/transaction-summary.test.ts
@@ -22,26 +22,66 @@ function createTransaction(overrides: Partial<Transaction>): Transaction {
 }
 
 describe('calculateTransactionSummary', () => {
-  it('calculates income, expense and balance', () => {
+  it('returns empty array for no transactions', () => {
+    expect(calculateTransactionSummary([])).toEqual([]);
+  });
+
+  it('calculates income, expense and balance within one currency', () => {
     expect(
       calculateTransactionSummary([
-        createTransaction({
-          amount: 1000,
-          id: 'income',
-          kind: 'income',
-          signedAmount: 1000,
-        }),
-        createTransaction({
-          amount: 250,
-          id: 'expense',
-          kind: 'expense',
-          signedAmount: -250,
-        }),
+        createTransaction({ amount: 1000, id: 'income', kind: 'income', signedAmount: 1000 }),
+        createTransaction({ amount: 250, id: 'expense', kind: 'expense', signedAmount: -250 }),
       ]),
-    ).toEqual({
-      balance: 750,
-      expense: 250,
-      income: 1000,
-    });
+    ).toEqual([{ currency: 'UAH', income: 1000, expense: 250, balance: 750 }]);
+  });
+
+  it('groups amounts by currency and never mixes them', () => {
+    const result = calculateTransactionSummary([
+      createTransaction({
+        amount: 1000,
+        id: 'uah-income',
+        kind: 'income',
+        signedAmount: 1000,
+        currency: 'UAH',
+      }),
+      createTransaction({
+        amount: 300,
+        id: 'usd-income',
+        kind: 'income',
+        signedAmount: 300,
+        currency: 'USD',
+      }),
+      createTransaction({
+        amount: 250,
+        id: 'uah-expense',
+        kind: 'expense',
+        signedAmount: -250,
+        currency: 'UAH',
+      }),
+      createTransaction({
+        amount: 100,
+        id: 'usd-expense',
+        kind: 'expense',
+        signedAmount: -100,
+        currency: 'USD',
+      }),
+    ]);
+
+    expect(result).toEqual(
+      expect.arrayContaining([
+        { currency: 'UAH', income: 1000, expense: 250, balance: 750 },
+        { currency: 'USD', income: 300, expense: 100, balance: 200 },
+      ]),
+    );
+    expect(result).toHaveLength(2);
+  });
+
+  it('preserves insertion order of first appearance', () => {
+    const result = calculateTransactionSummary([
+      createTransaction({ currency: 'EUR', id: 'eur' }),
+      createTransaction({ currency: 'UAH', id: 'uah' }),
+    ]);
+
+    expect(result.map((entry) => entry.currency)).toEqual(['EUR', 'UAH']);
   });
 });
diff --git a/app/src/features/manage-transactions/lib/transaction-summary.ts b/app/src/features/manage-transactions/lib/transaction-summary.ts
index 3dc049e..1ac6396 100644
--- a/app/src/features/manage-transactions/lib/transaction-summary.ts
+++ b/app/src/features/manage-transactions/lib/transaction-summary.ts
@@ -1,28 +1,28 @@
 import type { Transaction } from '@entities/transaction';
 
-export type TransactionSummary = {
+export type CurrencySummary = {
   balance: number;
+  currency: string;
   expense: number;
   income: number;
 };
 
-export function calculateTransactionSummary(transactions: Transaction[]): TransactionSummary {
-  return transactions.reduce<TransactionSummary>(
-    (summary, transaction) => {
-      if (transaction.kind === 'income') {
-        summary.income += transaction.amount;
-      } else {
-        summary.expense += transaction.amount;
-      }
+export function calculateTransactionSummary(transactions: Transaction[]): CurrencySummary[] {
+  const byCurrency = new Map<string, CurrencySummary>();
 
-      summary.balance += transaction.signedAmount;
+  for (const transaction of transactions) {
+    const { currency } = transaction;
+    const entry = byCurrency.get(currency) ?? { balance: 0, currency, expense: 0, income: 0 };
 
-      return summary;
-    },
-    {
-      balance: 0,
-      expense: 0,
-      income: 0,
-    },
-  );
+    if (transaction.kind === 'income') {
+      entry.income += transaction.amount;
+    } else {
+      entry.expense += transaction.amount;
+    }
+
+    entry.balance += transaction.signedAmount;
+    byCurrency.set(currency, entry);
+  }
+
+  return [...byCurrency.values()];
 }
diff --git a/app/src/features/manage-transactions/model/useOfflineSyncStatus.ts b/app/src/features/manage-transactions/model/useOfflineSyncStatus.ts
index f5984f9..cfec77c 100644
--- a/app/src/features/manage-transactions/model/useOfflineSyncStatus.ts
+++ b/app/src/features/manage-transactions/model/useOfflineSyncStatus.ts
@@ -1,6 +1,6 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { offlineTransactionsStorage } from '../lib/offline-transactions.storage';
+import { createOfflineTransactionsStorage } from '../lib/offline-transactions.storage';
 import type { TransactionQueueItem } from '../types/sync-queue.type';
 
 export type OfflineSyncStatus = {
@@ -25,13 +25,17 @@ const defaultStatus: OfflineSyncStatus = {
   totalQueued: 0,
 };
 
-export function useOfflineSyncStatus() {
+export function useOfflineSyncStatus(spreadsheetId: string | null = null) {
+  const storage = useMemo(
+    () => createOfflineTransactionsStorage(spreadsheetId ?? '__unscoped__'),
+    [spreadsheetId],
+  );
   const [status, setStatus] = useState<OfflineSyncStatus>(defaultStatus);
 
   const refresh = useCallback(async () => {
     const [diagnostics, queueItems] = await Promise.all([
-      offlineTransactionsStorage.getSyncDiagnostics(),
-      offlineTransactionsStorage.getQueueItems(),
+      storage.getSyncDiagnostics(),
+      storage.getQueueItems(),
     ]);
 
     setStatus({
@@ -39,15 +43,15 @@ export function useOfflineSyncStatus() {
       isOnline: typeof navigator === 'undefined' ? true : navigator.onLine,
       queueItems,
     });
-  }, []);
+  }, [storage]);
 
   useEffect(() => {
     let isActive = true;
 
     async function refreshIfActive() {
       const [diagnostics, queueItems] = await Promise.all([
-        offlineTransactionsStorage.getSyncDiagnostics(),
-        offlineTransactionsStorage.getQueueItems(),
+        storage.getSyncDiagnostics(),
+        storage.getQueueItems(),
       ]);
 
       if (isActive) {
@@ -75,7 +79,7 @@ export function useOfflineSyncStatus() {
       window.removeEventListener('online', handleNetworkChange);
       window.removeEventListener('offline', handleNetworkChange);
     };
-  }, []);
+  }, [storage]);
 
   return {
     refresh,
diff --git a/app/src/features/manage-transactions/model/useTransactions.ts b/app/src/features/manage-transactions/model/useTransactions.ts
index 923f136..5520ff0 100644
--- a/app/src/features/manage-transactions/model/useTransactions.ts
+++ b/app/src/features/manage-transactions/model/useTransactions.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import type { Transaction } from '@entities/transaction';
 import { useGoogleAuth } from '@features/google-auth';
@@ -6,7 +6,7 @@ import { localStorageService } from '@shared/lib/storage/local-storage.service';
 
 import { createGoogleSheetsDataSource } from '../lib/google-sheets-data-source';
 import { createLocalQueueDataSource } from '../lib/local-queue-data-source';
-import { offlineTransactionsStorage } from '../lib/offline-transactions.storage';
+import { createOfflineTransactionsStorage } from '../lib/offline-transactions.storage';
 
 function sortTransactions(transactions: Transaction[]) {
   return [...transactions].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
@@ -27,10 +27,13 @@ function markTransactionAsFailed(transaction: Transaction): Transaction {
   };
 }
 
-async function clearQueuedTransaction(transactionId: string) {
+async function clearQueuedTransaction(
+  storage: ReturnType<typeof createOfflineTransactionsStorage>,
+  transactionId: string,
+) {
   await Promise.all(
     ['create', 'update', 'delete'].map((operation) =>
-      offlineTransactionsStorage.removeQueueItem(`${operation}-${transactionId}`),
+      storage.removeQueueItem(`${operation}-${transactionId}`),
     ),
   );
 }
@@ -45,6 +48,37 @@ export function useTransactions() {
   const [isSyncing, setIsSyncing] = useState(false);
   const [syncWarning, setSyncWarning] = useState<string | null>(null);
 
+  const storage = useMemo(
+    () => createOfflineTransactionsStorage(spreadsheetId ?? '__unscoped__'),
+    [spreadsheetId],
+  );
+
+  const prevSpreadsheetId = useRef(spreadsheetId);
+
+  useEffect(() => {
+    const prevId = prevSpreadsheetId.current;
+
+    if (prevId !== spreadsheetId) {
+      prevSpreadsheetId.current = spreadsheetId;
+
+      setTransactions([]);
+      setError(null);
+      setSyncWarning(null);
+
+      if (prevId) {
+        const oldStorage = createOfflineTransactionsStorage(prevId);
+
+        void oldStorage.getQueueItems().then((items) => {
+          if (items.length > 0) {
+            setSyncWarning(
+              `${items.length} unsynced change${items.length !== 1 ? 's' : ''} remain from the previous spreadsheet.`,
+            );
+          }
+        });
+      }
+    }
+  }, [spreadsheetId]);
+
   const remoteDataSource = useCallback(() => {
     if (!googleAuth.accessToken || !spreadsheetId) {
       return null;
@@ -57,12 +91,13 @@ export function useTransactions() {
   }, [googleAuth.accessToken, spreadsheetId]);
 
   const localDataSource = useCallback(
-    () => createLocalQueueDataSource(remoteDataSource() ?? undefined),
-    [remoteDataSource],
+    () =>
+      createLocalQueueDataSource(remoteDataSource() ?? undefined, spreadsheetId ?? '__unscoped__'),
+    [remoteDataSource, spreadsheetId],
   );
 
   const loadTransactions = useCallback(async () => {
-    const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+    const cachedTransactions = await storage.getCachedTransactions();
 
     if (cachedTransactions.length) {
       setTransactions(cachedTransactions);
@@ -76,7 +111,7 @@ export function useTransactions() {
     }
 
     const loadedTransactions = await dataSource.getTransactions();
-    const pendingTransactions = (await offlineTransactionsStorage.getCachedTransactions()).filter(
+    const pendingTransactions = (await storage.getCachedTransactions()).filter(
       (transaction) => transaction.syncStatus !== 'synced',
     );
     const mergedTransactions = [
@@ -89,11 +124,11 @@ export function useTransactions() {
       ),
     ];
 
-    await offlineTransactionsStorage.cacheTransactions(mergedTransactions);
+    await storage.cacheTransactions(mergedTransactions);
     setSyncWarning(null);
 
     return mergedTransactions;
-  }, [remoteDataSource]);
+  }, [remoteDataSource, storage]);
 
   const refresh = useCallback(async () => {
     setIsLoading(true);
@@ -104,7 +139,7 @@ export function useTransactions() {
 
       setTransactions(loadedTransactions);
     } catch (caughtError) {
-      const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+      const cachedTransactions = await storage.getCachedTransactions();
 
       setTransactions(cachedTransactions);
       setError(caughtError instanceof Error ? caughtError.message : 'Could not load transactions.');
@@ -112,7 +147,7 @@ export function useTransactions() {
     } finally {
       setIsLoading(false);
     }
-  }, [loadTransactions]);
+  }, [loadTransactions, storage]);
 
   const syncCreatedTransaction = useCallback(
     async (transaction: Transaction) => {
@@ -133,8 +168,8 @@ export function useTransactions() {
         );
         const syncedTransaction = await dataSource.createTransaction(transaction);
 
-        await clearQueuedTransaction(transaction.id);
-        await offlineTransactionsStorage.upsertCachedTransaction(syncedTransaction);
+        await clearQueuedTransaction(storage, transaction.id);
+        await storage.upsertCachedTransaction(syncedTransaction);
         setTransactions((currentTransactions) =>
           upsertTransaction(currentTransactions, syncedTransaction),
         );
@@ -142,14 +177,14 @@ export function useTransactions() {
       } catch {
         const failedTransaction = markTransactionAsFailed(transaction);
 
-        await offlineTransactionsStorage.upsertCachedTransaction(failedTransaction);
+        await storage.upsertCachedTransaction(failedTransaction);
         setTransactions((currentTransactions) =>
           upsertTransaction(currentTransactions, failedTransaction),
         );
         setSyncWarning('Google is unavailable. Transaction was saved offline.');
       }
     },
-    [remoteDataSource],
+    [remoteDataSource, storage],
   );
 
   const syncUpdatedTransaction = useCallback(
@@ -171,8 +206,8 @@ export function useTransactions() {
         );
         const syncedTransaction = await dataSource.updateTransaction(transaction);
 
-        await clearQueuedTransaction(transaction.id);
-        await offlineTransactionsStorage.upsertCachedTransaction(syncedTransaction);
+        await clearQueuedTransaction(storage, transaction.id);
+        await storage.upsertCachedTransaction(syncedTransaction);
         setTransactions((currentTransactions) =>
           upsertTransaction(currentTransactions, syncedTransaction),
         );
@@ -180,14 +215,14 @@ export function useTransactions() {
       } catch {
         const failedTransaction = markTransactionAsFailed(transaction);
 
-        await offlineTransactionsStorage.upsertCachedTransaction(failedTransaction);
+        await storage.upsertCachedTransaction(failedTransaction);
         setTransactions((currentTransactions) =>
           upsertTransaction(currentTransactions, failedTransaction),
         );
         setSyncWarning('Google is unavailable. Update was saved offline.');
       }
     },
-    [remoteDataSource],
+    [remoteDataSource, storage],
   );
 
   const syncDeletedTransaction = useCallback(
@@ -211,7 +246,7 @@ export function useTransactions() {
         }
 
         await dataSource.softDeleteTransaction(transactionId);
-        await clearQueuedTransaction(transactionId);
+        await clearQueuedTransaction(storage, transactionId);
         if (deletedTransaction) {
           const syncedDeletedTransaction: Transaction = {
             ...deletedTransaction,
@@ -219,7 +254,7 @@ export function useTransactions() {
             syncStatus: 'synced',
           };
 
-          await offlineTransactionsStorage.upsertCachedTransaction(syncedDeletedTransaction);
+          await storage.upsertCachedTransaction(syncedDeletedTransaction);
           setTransactions((currentTransactions) =>
             upsertTransaction(currentTransactions, syncedDeletedTransaction),
           );
@@ -229,7 +264,7 @@ export function useTransactions() {
         if (deletedTransaction) {
           const failedTransaction = markTransactionAsFailed(deletedTransaction);
 
-          await offlineTransactionsStorage.upsertCachedTransaction(failedTransaction);
+          await storage.upsertCachedTransaction(failedTransaction);
           setTransactions((currentTransactions) =>
             upsertTransaction(currentTransactions, failedTransaction),
           );
@@ -237,14 +272,14 @@ export function useTransactions() {
         setSyncWarning('Google is unavailable. Delete was saved offline.');
       }
     },
-    [remoteDataSource],
+    [remoteDataSource, storage],
   );
 
   useEffect(() => {
     let isActive = true;
 
     async function loadInitialTransactions() {
-      const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+      const cachedTransactions = await storage.getCachedTransactions();
 
       if (!isActive) {
         return;
@@ -265,7 +300,7 @@ export function useTransactions() {
         }
       } catch (caughtError) {
         if (isActive) {
-          const fallbackTransactions = await offlineTransactionsStorage.getCachedTransactions();
+          const fallbackTransactions = await storage.getCachedTransactions();
 
           setTransactions(fallbackTransactions);
           setError(
@@ -285,7 +320,7 @@ export function useTransactions() {
     return () => {
       isActive = false;
     };
-  }, [loadTransactions]);
+  }, [loadTransactions, storage]);
 
   useEffect(() => {
     function refreshSpreadsheetId() {
@@ -349,13 +384,13 @@ export function useTransactions() {
     setError(null);
 
     try {
-      const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+      const cachedTransactions = await storage.getCachedTransactions();
       const deletedTransaction = cachedTransactions.find(
         (transaction) => transaction.id === transactionId,
       );
 
       await localDataSource().softDeleteTransaction(transactionId);
-      const nextCachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+      const nextCachedTransactions = await storage.getCachedTransactions();
 
       setTransactions(nextCachedTransactions);
       void syncDeletedTransaction(
@@ -378,7 +413,7 @@ export function useTransactions() {
 
     try {
       const result = await localDataSource().syncPending();
-      const cachedTransactions = await offlineTransactionsStorage.getCachedTransactions();
+      const cachedTransactions = await storage.getCachedTransactions();
 
       setTransactions(cachedTransactions);
       setSyncWarning(
@@ -393,7 +428,7 @@ export function useTransactions() {
     } finally {
       setIsSyncing(false);
     }
-  }, [localDataSource]);
+  }, [localDataSource, storage]);
 
   useEffect(() => {
     if (!googleAuth.accessToken || !spreadsheetId) {
@@ -401,7 +436,7 @@ export function useTransactions() {
     }
 
     async function syncQueuedChanges() {
-      const queueItems = await offlineTransactionsStorage.getQueueItems();
+      const queueItems = await storage.getQueueItems();
 
       if (queueItems.length) {
         void retrySync();
@@ -409,7 +444,7 @@ export function useTransactions() {
     }
 
     void syncQueuedChanges();
-  }, [googleAuth.accessToken, retrySync, spreadsheetId]);
+  }, [googleAuth.accessToken, retrySync, spreadsheetId, storage]);
 
   useEffect(() => {
     if (typeof window === 'undefined') {
diff --git a/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.test.ts b/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.test.ts
index 0fca2ae..ea9da3a 100644
--- a/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.test.ts
+++ b/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.test.ts
@@ -26,6 +26,7 @@ describe('setupSpreadsheet', () => {
             'Ledger',
             'Categories',
             'Containers',
+            'Currencies',
             'Summary',
             'MonthlyStats',
             'CategoryStats',
@@ -53,6 +54,7 @@ describe('setupSpreadsheet', () => {
       createdSheets: [
         'Categories',
         'Containers',
+        'Currencies',
         'Summary',
         'MonthlyStats',
         'CategoryStats',
@@ -97,6 +99,9 @@ describe('setupSpreadsheet', () => {
         expect.objectContaining({
           range: 'Containers!A2:G',
         }),
+        expect.objectContaining({
+          range: 'Currencies!A2:G',
+        }),
       ]),
       spreadsheetId: 'sheet-id',
     });
@@ -112,6 +117,7 @@ describe('setupSpreadsheet', () => {
           'Ledger',
           'Categories',
           'Containers',
+          'Currencies',
           'Summary',
           'MonthlyStats',
           'CategoryStats',
@@ -149,6 +155,9 @@ describe('setupSpreadsheet', () => {
         expect.objectContaining({
           range: 'Categories!A2:F',
         }),
+        expect.objectContaining({
+          range: 'Currencies!A2:G',
+        }),
       ]),
     );
   });
diff --git a/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.ts b/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.ts
index 1f63dbd..e896877 100644
--- a/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.ts
+++ b/app/src/features/setup-spreadsheet/lib/setup-spreadsheet.service.ts
@@ -23,19 +23,18 @@ export type SetupSpreadsheetResult = {
   status: 'ready';
 };
 
-async function hasExistingCategories({
-  accessToken,
-  googleSheetsClient,
-  spreadsheetId,
-}: Required<SetupSpreadsheetParams>) {
+async function hasExistingRows(
+  { accessToken, googleSheetsClient, spreadsheetId }: Required<SetupSpreadsheetParams>,
+  range: string,
+) {
   try {
-    const categories = await googleSheetsClient.readRange({
+    const existing = await googleSheetsClient.readRange({
       accessToken,
-      range: sheetRanges.categoriesData,
+      range,
       spreadsheetId,
     });
 
-    return categories.values.length > 0;
+    return existing.values.length > 0;
   } catch {
     return false;
   }
@@ -67,15 +66,17 @@ export async function setupSpreadsheet({
       })
     : metadata;
 
-  const includeDefaultCategories = !(await hasExistingCategories({
-    accessToken,
-    googleSheetsClient,
-    spreadsheetId,
-  }));
+  const [hasCategories, hasCurrencies] = await Promise.all([
+    hasExistingRows({ accessToken, googleSheetsClient, spreadsheetId }, sheetRanges.categoriesData),
+    hasExistingRows({ accessToken, googleSheetsClient, spreadsheetId }, sheetRanges.currenciesData),
+  ]);
 
   await googleSheetsClient.batchUpdateValues({
     accessToken,
-    data: buildTemplateValueRanges(includeDefaultCategories),
+    data: buildTemplateValueRanges({
+      includeDefaultCategories: !hasCategories,
+      includeDefaultCurrencies: !hasCurrencies,
+    }),
     spreadsheetId,
   });
 
diff --git a/app/src/features/setup-spreadsheet/lib/spreadsheet-template-formatting.ts b/app/src/features/setup-spreadsheet/lib/spreadsheet-template-formatting.ts
index 5ab4e7b..b59b0d0 100644
--- a/app/src/features/setup-spreadsheet/lib/spreadsheet-template-formatting.ts
+++ b/app/src/features/setup-spreadsheet/lib/spreadsheet-template-formatting.ts
@@ -52,6 +52,12 @@ const styles: Record<string, SheetStyle> = {
     tabColor: { blue: 0.12, green: 0.46, red: 0.06 },
     widths: [160, 180, 110, 110, 120, 110, 180],
   },
+  [sheetNames.currencies]: {
+    columns: 7,
+    headerColor: { blue: 0.1, green: 0.55, red: 0.85 },
+    tabColor: { blue: 0.1, green: 0.55, red: 0.85 },
+    widths: [90, 90, 200, 90, 120, 110, 110],
+  },
   [sheetNames.summary]: {
     columns: 2,
     headerColor: { blue: 0.16, green: 0.18, red: 0.07 },
@@ -262,6 +268,10 @@ function buildSheetSpecificFormattingRequests(
     return [buildNumberFormatRequest(sheetId, 6, 7, 'DATE_TIME', 'yyyy-mm-dd hh:mm')];
   }
 
+  if (sheetName === sheetNames.currencies) {
+    return [buildNumberFormatRequest(sheetId, 4, 5, 'NUMBER', '0')];
+  }
+
   return [];
 }
 
diff --git a/app/src/features/setup-spreadsheet/lib/spreadsheet-template.test.ts b/app/src/features/setup-spreadsheet/lib/spreadsheet-template.test.ts
index 45836f3..394d75c 100644
--- a/app/src/features/setup-spreadsheet/lib/spreadsheet-template.test.ts
+++ b/app/src/features/setup-spreadsheet/lib/spreadsheet-template.test.ts
@@ -19,7 +19,15 @@ describe('spreadsheet template helpers', () => {
           },
         ],
       }),
-    ).toEqual(['Categories', 'Containers', 'Summary', 'MonthlyStats', 'CategoryStats', 'Settings']);
+    ).toEqual([
+      'Categories',
+      'Containers',
+      'Currencies',
+      'Summary',
+      'MonthlyStats',
+      'CategoryStats',
+      'Settings',
+    ]);
   });
 
   it('builds addSheet requests', () => {
@@ -34,8 +42,11 @@ describe('spreadsheet template helpers', () => {
     ]);
   });
 
-  it('builds template value ranges with default categories', () => {
-    const ranges = buildTemplateValueRanges(true);
+  it('builds template value ranges with default categories and currencies', () => {
+    const ranges = buildTemplateValueRanges({
+      includeDefaultCategories: true,
+      includeDefaultCurrencies: true,
+    });
 
     expect(ranges).toEqual(
       expect.arrayContaining([
@@ -48,9 +59,20 @@ describe('spreadsheet template helpers', () => {
         expect.objectContaining({
           range: 'Containers!A2:G',
         }),
+        expect.objectContaining({
+          range: 'Currencies!A1:G1',
+          values: [['id', 'code', 'name', 'symbol', 'decimalDigits', 'isDefault', 'isEnabled']],
+        }),
+        expect.objectContaining({
+          range: 'Currencies!A2:G',
+          values: expect.arrayContaining([
+            ['uah', 'UAH', 'Ukrainian Hryvnia', '₴', '2', 'TRUE', 'TRUE'],
+            ['jpy', 'JPY', 'Japanese Yen', '¥', '0', 'TRUE', 'TRUE'],
+          ]),
+        }),
         expect.objectContaining({
           range: 'Settings!A2:B2',
-          values: [['templateVersion', '2']],
+          values: [['templateVersion', '4']],
         }),
         expect.objectContaining({
           range: 'Summary!A:B',
@@ -60,28 +82,51 @@ describe('spreadsheet template helpers', () => {
           ]),
         }),
         expect.objectContaining({
-          range: 'MonthlyStats!A1:D1',
-          values: [['month', 'income', 'expense', 'balance']],
+          range: 'Summary!A8',
+          values: [[expect.stringContaining('QUERY(FILTER')]],
+        }),
+        expect.objectContaining({
+          range: 'MonthlyStats!A1:E1',
+          values: [['month', 'currency', 'income', 'expense', 'balance']],
         }),
         expect.objectContaining({
           range: 'MonthlyStats!A2',
           values: [[expect.stringContaining('QUERY(FILTER')]],
         }),
         expect.objectContaining({
-          range: 'CategoryStats!A1:D1',
-          values: [['category', 'kind', 'total', 'count']],
+          range: 'CategoryStats!A1:E1',
+          values: [['category', 'kind', 'currency', 'total', 'count']],
         }),
         expect.objectContaining({
           range: 'CategoryStats!A2',
-          values: [[expect.stringContaining('group by Col1, Col2')]],
+          values: [[expect.stringContaining('group by Col1, Col2, Col3')]],
         }),
       ]),
     );
   });
 
-  it('skips default categories when requested', () => {
-    expect(buildTemplateValueRanges(false).some((range) => range.range === 'Categories!A2:F')).toBe(
-      false,
+  it('always writes currency headers even when seed rows are skipped', () => {
+    const ranges = buildTemplateValueRanges({
+      includeDefaultCategories: false,
+      includeDefaultCurrencies: false,
+    });
+
+    expect(ranges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          range: 'Currencies!A1:G1',
+        }),
+      ]),
     );
   });
+
+  it('skips default categories and currencies when requested', () => {
+    const ranges = buildTemplateValueRanges({
+      includeDefaultCategories: false,
+      includeDefaultCurrencies: false,
+    });
+
+    expect(ranges.some((range) => range.range === 'Categories!A2:F')).toBe(false);
+    expect(ranges.some((range) => range.range === 'Currencies!A2:G')).toBe(false);
+  });
 });
diff --git a/app/src/features/setup-spreadsheet/lib/spreadsheet-template.ts b/app/src/features/setup-spreadsheet/lib/spreadsheet-template.ts
index b18d4c1..97af985 100644
--- a/app/src/features/setup-spreadsheet/lib/spreadsheet-template.ts
+++ b/app/src/features/setup-spreadsheet/lib/spreadsheet-template.ts
@@ -1,5 +1,6 @@
 import { getDefaultCategories } from '@entities/category';
 import { getDefaultContainers } from '@entities/container';
+import { getDefaultCurrencies } from '@entities/currency';
 import type {
   SpreadsheetMetadata,
   SpreadsheetBatchUpdateRequest,
@@ -9,6 +10,7 @@ import {
   categoryStatsHeaders,
   categoryHeaders,
   containerHeaders,
+  currencyHeaders,
   ledgerHeaders,
   monthlyStatsHeaders,
   requiredSheetNames,
@@ -19,12 +21,16 @@ import {
 } from '@shared/config/constants/sheet.constants';
 import { mapCategoryToRow } from '@features/manage-categories';
 import { mapContainerToRow } from '@features/manage-containers';
+import { mapCurrencyToRow } from '@features/manage-currencies';
 
 const monthlyStatsFormula =
-  '=IFERROR(QUERY(FILTER({TEXT(Ledger!B2:B,"yyyy-mm"),IF(Ledger!C2:C="income",Ledger!E2:E,0),IF(Ledger!C2:C="expense",Ledger!E2:E,0),Ledger!F2:F},Ledger!A2:A<>"",Ledger!N2:N=""),"select Col1, sum(Col2), sum(Col3), sum(Col4) group by Col1 label Col1 \'\', sum(Col2) \'\', sum(Col3) \'\', sum(Col4) \'\'",0),)';
+  '=IFERROR(QUERY(FILTER({TEXT(Ledger!B2:B,"yyyy-mm"),Ledger!G2:G,IF(Ledger!C2:C="income",Ledger!E2:E,0),IF(Ledger!C2:C="expense",Ledger!E2:E,0),Ledger!F2:F},Ledger!A2:A<>"",Ledger!N2:N=""),"select Col1, Col2, sum(Col3), sum(Col4), sum(Col5) group by Col1, Col2 label Col1 \'\', Col2 \'\', sum(Col3) \'\', sum(Col4) \'\', sum(Col5) \'\'",0),)';
 
 const categoryStatsFormula =
-  "=IFERROR(QUERY(FILTER({Ledger!D2:D,Ledger!C2:C,Ledger!E2:E},Ledger!A2:A<>\"\",Ledger!N2:N=\"\"),\"select Col1, Col2, sum(Col3), count(Col3) group by Col1, Col2 label Col1 '', Col2 '', sum(Col3) '', count(Col3) ''\",0),)";
+  "=IFERROR(QUERY(FILTER({Ledger!D2:D,Ledger!C2:C,Ledger!G2:G,Ledger!E2:E},Ledger!A2:A<>\"\",Ledger!N2:N=\"\"),\"select Col1, Col2, Col3, sum(Col4), count(Col4) group by Col1, Col2, Col3 label Col1 '', Col2 '', Col3 '', sum(Col4) '', count(Col4) ''\",0),)";
+
+const summaryByCurrencyFormula =
+  '=IFERROR(QUERY(FILTER({Ledger!G2:G,IF(Ledger!C2:C="income",Ledger!E2:E,0),IF(Ledger!C2:C="expense",Ledger!E2:E,0)},Ledger!A2:A<>"",Ledger!N2:N=""),"select Col1, sum(Col2), sum(Col3) group by Col1 label Col1 \'Currency\', sum(Col2) \'Income\', sum(Col3) \'Expense\'",0),)';
 
 export function getExistingSheetNames(metadata: SpreadsheetMetadata) {
   return new Set(
@@ -50,7 +56,15 @@ export function buildAddSheetRequests(sheetNames: string[]): SpreadsheetBatchUpd
   }));
 }
 
-export function buildTemplateValueRanges(includeDefaultCategories: boolean): ValueRange[] {
+export type BuildTemplateValueRangesOptions = {
+  includeDefaultCategories: boolean;
+  includeDefaultCurrencies: boolean;
+};
+
+export function buildTemplateValueRanges({
+  includeDefaultCategories,
+  includeDefaultCurrencies,
+}: BuildTemplateValueRangesOptions): ValueRange[] {
   const valueRanges: ValueRange[] = [
     {
       range: sheetRanges.ledgerHeaders,
@@ -64,6 +78,10 @@ export function buildTemplateValueRanges(includeDefaultCategories: boolean): Val
       range: sheetRanges.containersHeaders,
       values: [[...containerHeaders]],
     },
+    {
+      range: sheetRanges.currenciesHeaders,
+      values: [[...currencyHeaders]],
+    },
     {
       range: sheetRanges.settingsHeaders,
       values: [[...settingsHeaders]],
@@ -95,6 +113,10 @@ export function buildTemplateValueRanges(includeDefaultCategories: boolean): Val
         ['Average Expense', '=IFERROR(AVERAGEIF(Ledger!C:C,"expense",Ledger!E:E),0)'],
       ],
     },
+    {
+      range: sheetRanges.summaryByCurrencyFormula,
+      values: [[summaryByCurrencyFormula]],
+    },
     {
       range: sheetRanges.settingsTemplateVersion,
       values: [['templateVersion', templateVersion]],
@@ -112,5 +134,12 @@ export function buildTemplateValueRanges(includeDefaultCategories: boolean): Val
     });
   }
 
+  if (includeDefaultCurrencies) {
+    valueRanges.push({
+      range: sheetRanges.currenciesData,
+      values: getDefaultCurrencies().map(mapCurrencyToRow),
+    });
+  }
+
   return valueRanges;
 }
diff --git a/app/src/pages/dashboard/ui/DashboardPage.tsx b/app/src/pages/dashboard/ui/DashboardPage.tsx
index 296a0d8..757f6f6 100644
--- a/app/src/pages/dashboard/ui/DashboardPage.tsx
+++ b/app/src/pages/dashboard/ui/DashboardPage.tsx
@@ -4,7 +4,11 @@ import type { Transaction } from '@entities/transaction';
 import { CreateTransactionModal } from '@features/create-transaction';
 import { GoogleConnectButton, GoogleConnectionStatus, useGoogleAuth } from '@features/google-auth';
 import { useContainers } from '@features/manage-containers';
-import { calculateTransactionSummary, useTransactions } from '@features/manage-transactions';
+import {
+  calculateTransactionSummary,
+  type CurrencySummary,
+  useTransactions,
+} from '@features/manage-transactions';
 import { AppLayout } from '@widgets/app-layout';
 import { DashboardAnalytics } from '@widgets/dashboard-analytics';
 import { TransactionsHistory } from '@widgets/transactions-history';
@@ -13,15 +17,41 @@ import { Card } from '@shared/ui/card';
 import { ConfirmModal } from '@shared/ui/confirm-modal';
 import { PageHeader } from '@shared/ui/page-header';
 
-const defaultCurrency = 'UAH';
-
-function formatMoney(amount: number, currency = defaultCurrency) {
+function formatMoney(amount: number, currency: string) {
   return `${amount.toLocaleString('en-US', {
     maximumFractionDigits: 2,
     minimumFractionDigits: 0,
   })} ${currency}`;
 }
 
+type SummaryCardProps = {
+  label: string;
+  getValue: (entry: CurrencySummary) => number;
+  summaries: CurrencySummary[];
+};
+
+function SummaryCard({ label, getValue, summaries }: SummaryCardProps) {
+  return (
+    <Card>
+      <p className="text-sm text-zinc-500">{label}</p>
+      {summaries.length === 0 ? (
+        <p className="mt-2 text-xl font-semibold text-zinc-500 md:text-2xl">—</p>
+      ) : (
+        <ul className="mt-2 space-y-1">
+          {summaries.map((entry) => (
+            <li
+              className="break-words text-xl font-semibold text-zinc-950 md:text-2xl"
+              key={entry.currency}
+            >
+              {formatMoney(getValue(entry), entry.currency)}
+            </li>
+          ))}
+        </ul>
+      )}
+    </Card>
+  );
+}
+
 export function DashboardPage() {
   const [isCreateTransactionOpen, setIsCreateTransactionOpen] = useState(false);
   const [editingTransaction, setEditingTransaction] = useState<Transaction | null>(null);
@@ -43,8 +73,7 @@ export function DashboardPage() {
     updateAndRefresh,
   } = useTransactions();
   const activeTransactions = transactions.filter((transaction) => !transaction.deletedAt);
-  const summary = calculateTransactionSummary(activeTransactions);
-  const currency = activeTransactions[0]?.currency ?? defaultCurrency;
+  const summaries = calculateTransactionSummary(activeTransactions);
   const lastSelectedContainerId = localStorage.getItem('lastSelectedContainerId');
   const initialContainer =
     containers.find((container) => container.id === lastSelectedContainerId) ??
@@ -65,25 +94,10 @@ export function DashboardPage() {
         description="Track income, expenses and balance from your Google Sheets ledger."
         title="Dashboard"
       />
-      <section className="grid gap-4 md:grid-cols-3">
-        <Card>
-          <p className="text-sm text-zinc-500">Income</p>
-          <p className="mt-2 text-2xl font-semibold text-zinc-950">
-            {formatMoney(summary.income, currency)}
-          </p>
-        </Card>
-        <Card>
-          <p className="text-sm text-zinc-500">Expense</p>
-          <p className="mt-2 text-2xl font-semibold text-zinc-950">
-            {formatMoney(summary.expense, currency)}
-          </p>
-        </Card>
-        <Card>
-          <p className="text-sm text-zinc-500">Balance</p>
-          <p className="mt-2 text-2xl font-semibold text-zinc-950">
-            {formatMoney(summary.balance, currency)}
-          </p>
-        </Card>
+      <section className="grid gap-3 sm:grid-cols-3 md:gap-4">
+        <SummaryCard getValue={(entry) => entry.income} label="Income" summaries={summaries} />
+        <SummaryCard getValue={(entry) => entry.expense} label="Expense" summaries={summaries} />
+        <SummaryCard getValue={(entry) => entry.balance} label="Balance" summaries={summaries} />
       </section>
       <DashboardAnalytics transactions={activeTransactions} />
       <TransactionsHistory
diff --git a/app/src/pages/settings/ui/SettingsPage.tsx b/app/src/pages/settings/ui/SettingsPage.tsx
index 0950863..750eebb 100644
--- a/app/src/pages/settings/ui/SettingsPage.tsx
+++ b/app/src/pages/settings/ui/SettingsPage.tsx
@@ -4,7 +4,7 @@ import { ConnectSpreadsheetModal } from '@features/connect-spreadsheet';
 import { GoogleConnectButton, GoogleConnectionStatus, useGoogleAuth } from '@features/google-auth';
 import { ManageContainersModal } from '@features/manage-containers';
 import {
-  offlineTransactionsStorage,
+  createOfflineTransactionsStorage,
   useOfflineSyncStatus,
   useTransactions,
 } from '@features/manage-transactions';
@@ -34,7 +34,7 @@ export function SettingsPage() {
   const [theme, setTheme] = useState(localStorageService.get('theme') ?? 'system');
   const spreadsheetId = localStorageService.get('spreadsheetId');
   const googleAuth = useGoogleAuth();
-  const { refresh: refreshSyncStatus, status: syncStatus } = useOfflineSyncStatus();
+  const { refresh: refreshSyncStatus, status: syncStatus } = useOfflineSyncStatus(spreadsheetId);
   const { isSyncing, retrySync } = useTransactions();
 
   function toggleContainers(enabled: boolean) {
@@ -108,7 +108,7 @@ export function SettingsPage() {
   }
 
   async function resetOfflineCache() {
-    await offlineTransactionsStorage.resetOfflineData();
+    await createOfflineTransactionsStorage(spreadsheetId ?? '__unscoped__').resetOfflineData();
     await refreshSyncStatus();
     setIsResetOpen(false);
     setSettingsMessage('Offline cache and sync queues were reset.');
@@ -120,7 +120,7 @@ export function SettingsPage() {
   }
 
   async function clearFailedQueue() {
-    await offlineTransactionsStorage.clearFailedQueue();
+    await createOfflineTransactionsStorage(spreadsheetId ?? '__unscoped__').clearFailedQueue();
     await refreshSyncStatus();
     setSettingsMessage('Failed sync queue was cleared.');
   }
@@ -223,24 +223,26 @@ export function SettingsPage() {
             hint="Stored locally for upcoming localization polish."
             id="language"
             label="Language"
-            onChange={(event) => updatePreference('language', event.target.value)}
+            onChange={(value) => updatePreference('language', value)}
+            options={[
+              { label: 'English', value: 'en' },
+              { label: 'Russian', value: 'ru' },
+              { label: 'Ukrainian', value: 'uk' },
+            ]}
             value={language}
-          >
-            <option value="en">English</option>
-            <option value="ru">Russian</option>
-            <option value="uk">Ukrainian</option>
-          </Select>
+          />
           <Select
             hint="Theme wiring is prepared for the next UI polish pass."
             id="theme"
             label="Theme"
-            onChange={(event) => updatePreference('theme', event.target.value)}
+            onChange={(value) => updatePreference('theme', value)}
+            options={[
+              { label: 'System', value: 'system' },
+              { label: 'Light', value: 'light' },
+              { label: 'Dark', value: 'dark' },
+            ]}
             value={theme}
-          >
-            <option value="system">System</option>
-            <option value="light">Light</option>
-            <option value="dark">Dark</option>
-          </Select>
+          />
         </div>
       </Card>
       <Card>
diff --git a/app/src/shared/config/constants/sheet.constants.ts b/app/src/shared/config/constants/sheet.constants.ts
index b77cca4..5bb0aa4 100644
--- a/app/src/shared/config/constants/sheet.constants.ts
+++ b/app/src/shared/config/constants/sheet.constants.ts
@@ -2,6 +2,7 @@ export const sheetNames = {
   ledger: 'Ledger',
   categories: 'Categories',
   containers: 'Containers',
+  currencies: 'Currencies',
   summary: 'Summary',
   monthlyStats: 'MonthlyStats',
   categoryStats: 'CategoryStats',
@@ -39,20 +40,31 @@ export const containerHeaders = [
   'createdAt',
 ] as const;
 
+export const currencyHeaders = [
+  'id',
+  'code',
+  'name',
+  'symbol',
+  'decimalDigits',
+  'isDefault',
+  'isEnabled',
+] as const;
+
 export const summaryHeaders = ['metric', 'value'] as const;
 
-export const monthlyStatsHeaders = ['month', 'income', 'expense', 'balance'] as const;
+export const monthlyStatsHeaders = ['month', 'currency', 'income', 'expense', 'balance'] as const;
 
-export const categoryStatsHeaders = ['category', 'kind', 'total', 'count'] as const;
+export const categoryStatsHeaders = ['category', 'kind', 'currency', 'total', 'count'] as const;
 
 export const settingsHeaders = ['key', 'value'] as const;
 
-export const templateVersion = '2';
+export const templateVersion = '4';
 
 export const requiredSheetNames = [
   sheetNames.ledger,
   sheetNames.categories,
   sheetNames.containers,
+  sheetNames.currencies,
   sheetNames.summary,
   sheetNames.monthlyStats,
   sheetNames.categoryStats,
@@ -66,16 +78,20 @@ export const sheetRanges = {
   containers: `${sheetNames.containers}!A:G`,
   containersData: `${sheetNames.containers}!A2:G`,
   containersHeaders: `${sheetNames.containers}!A1:G1`,
+  currencies: `${sheetNames.currencies}!A:G`,
+  currenciesData: `${sheetNames.currencies}!A2:G`,
+  currenciesHeaders: `${sheetNames.currencies}!A1:G1`,
   ledger: `${sheetNames.ledger}!A:P`,
   ledgerData: `${sheetNames.ledger}!A2:P`,
   ledgerHeaders: `${sheetNames.ledger}!A1:P1`,
-  categoryStatsHeaders: `${sheetNames.categoryStats}!A1:D1`,
-  categoryStatsData: `${sheetNames.categoryStats}!A2:D`,
+  categoryStatsHeaders: `${sheetNames.categoryStats}!A1:E1`,
+  categoryStatsData: `${sheetNames.categoryStats}!A2:E`,
   categoryStatsFormula: `${sheetNames.categoryStats}!A2`,
-  monthlyStatsHeaders: `${sheetNames.monthlyStats}!A1:D1`,
-  monthlyStatsData: `${sheetNames.monthlyStats}!A2:D`,
+  monthlyStatsHeaders: `${sheetNames.monthlyStats}!A1:E1`,
+  monthlyStatsData: `${sheetNames.monthlyStats}!A2:E`,
   monthlyStatsFormula: `${sheetNames.monthlyStats}!A2`,
   summary: `${sheetNames.summary}!A:B`,
+  summaryByCurrencyFormula: `${sheetNames.summary}!A8`,
   settingsHeaders: `${sheetNames.settings}!A1:B1`,
   settingsTemplateVersion: `${sheetNames.settings}!A2:B2`,
 } as const;
diff --git a/app/src/shared/lib/storage/storage-keys.ts b/app/src/shared/lib/storage/storage-keys.ts
index 05cbc3b..476fdd3 100644
--- a/app/src/shared/lib/storage/storage-keys.ts
+++ b/app/src/shared/lib/storage/storage-keys.ts
@@ -16,6 +16,7 @@ export type LocalStorageKey =
   | 'templateReadyAt'
   | 'templateReadySpreadsheetId'
   | 'templateReadyVersion'
+  | 'analyticsActiveCurrency'
   | 'analyticsChartSlots'
   | 'analyticsWideChartId'
   | 'googleAuthEverConnected';
@@ -38,6 +39,7 @@ export const localStorageKeys: LocalStorageKey[] = [
   'templateReadyAt',
   'templateReadySpreadsheetId',
   'templateReadyVersion',
+  'analyticsActiveCurrency',
   'analyticsChartSlots',
   'analyticsWideChartId',
   'googleAuthEverConnected',
diff --git a/app/src/shared/ui/date-picker/DatePicker.tsx b/app/src/shared/ui/date-picker/DatePicker.tsx
new file mode 100644
index 0000000..eab2290
--- /dev/null
+++ b/app/src/shared/ui/date-picker/DatePicker.tsx
@@ -0,0 +1,261 @@
+import { useEffect, useId, useRef, useState } from 'react';
+
+import { cn } from '@shared/lib/classnames/cn';
+
+type DatePickerProps = {
+  error?: string;
+  hint?: string;
+  id?: string;
+  label?: string;
+  onChange: (value: string) => void;
+  value: string;
+};
+
+const WEEKDAYS = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'];
+const MONTHS = [
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December',
+];
+
+function toDateString(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+function formatDisplay(value: string): string {
+  if (!value) return '';
+  const [year, month, day] = value.split('-');
+  return `${day}.${month}.${year}`;
+}
+
+export function DatePicker({ error, hint, id, label, onChange, value }: DatePickerProps) {
+  const generatedId = useId();
+  const inputId = id ?? generatedId;
+  const description = error ?? hint;
+
+  const [isOpen, setIsOpen] = useState(false);
+
+  const today = new Date();
+  const initialDate = value ? new Date(`${value}T00:00:00`) : today;
+  const [viewDate, setViewDate] = useState(
+    new Date(initialDate.getFullYear(), initialDate.getMonth(), 1),
+  );
+
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!isOpen) return;
+
+    function handlePointerDown(e: PointerEvent) {
+      if (!containerRef.current?.contains(e.target as Node)) {
+        setIsOpen(false);
+      }
+    }
+
+    function handleKeyDown(e: KeyboardEvent) {
+      if (e.key === 'Escape') setIsOpen(false);
+    }
+
+    document.addEventListener('pointerdown', handlePointerDown);
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('pointerdown', handlePointerDown);
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [isOpen]);
+
+  function moveMonth(direction: -1 | 1) {
+    setViewDate((d) => new Date(d.getFullYear(), d.getMonth() + direction, 1));
+  }
+
+  const firstWeekday = (viewDate.getDay() + 6) % 7;
+  const daysInMonth = new Date(viewDate.getFullYear(), viewDate.getMonth() + 1, 0).getDate();
+  const todayStr = toDateString(today);
+
+  return (
+    <div className="relative grid gap-2 text-sm font-medium text-zinc-700" ref={containerRef}>
+      {label ? <span id={`${inputId}-label`}>{label}</span> : null}
+
+      <button
+        aria-expanded={isOpen}
+        aria-haspopup="dialog"
+        aria-labelledby={label ? `${inputId}-label` : undefined}
+        className={cn(
+          'flex h-10 w-full items-center justify-between gap-2 rounded-md border border-zinc-200 bg-white px-3 text-left text-sm outline-none transition hover:border-zinc-300 focus:border-brand focus:ring-2 focus:ring-indigo-100',
+          value ? 'text-zinc-900' : 'text-zinc-400',
+          error && 'border-danger focus:border-danger focus:ring-red-100',
+        )}
+        id={inputId}
+        onClick={() => setIsOpen((o) => !o)}
+        type="button"
+      >
+        <span>{value ? formatDisplay(value) : 'dd.mm.yyyy'}</span>
+        <CalendarIcon />
+      </button>
+
+      {description ? (
+        <span className={cn('text-xs font-normal text-zinc-500', error && 'text-danger')}>
+          {description}
+        </span>
+      ) : null}
+
+      {isOpen ? (
+        <div
+          className="absolute left-0 top-full z-50 mt-1.5 w-[min(18rem,calc(100vw-2rem))] overflow-hidden rounded-xl border border-zinc-200 bg-white shadow-xl"
+          role="dialog"
+        >
+          <div className="flex items-center justify-between px-3 py-2.5">
+            <button
+              className="flex size-7 items-center justify-center rounded-md text-zinc-400 transition hover:bg-zinc-100 hover:text-zinc-700"
+              onClick={() => moveMonth(-1)}
+              type="button"
+            >
+              <ChevronLeftIcon />
+            </button>
+            <span className="text-sm font-semibold text-zinc-900">
+              {MONTHS[viewDate.getMonth()]} {viewDate.getFullYear()}
+            </span>
+            <button
+              className="flex size-7 items-center justify-center rounded-md text-zinc-400 transition hover:bg-zinc-100 hover:text-zinc-700"
+              onClick={() => moveMonth(1)}
+              type="button"
+            >
+              <ChevronRightIcon />
+            </button>
+          </div>
+
+          <div className="px-3 pb-2">
+            <div className="grid grid-cols-7">
+              {WEEKDAYS.map((day) => (
+                <div className="py-1 text-center text-xs font-medium text-zinc-400" key={day}>
+                  {day}
+                </div>
+              ))}
+            </div>
+
+            <div className="grid grid-cols-7 gap-0.5">
+              {Array.from({ length: firstWeekday }, (_, i) => (
+                <span key={`empty-${i}`} />
+              ))}
+              {Array.from({ length: daysInMonth }, (_, i) => {
+                const day = i + 1;
+                const dateStr = toDateString(
+                  new Date(viewDate.getFullYear(), viewDate.getMonth(), day),
+                );
+                const isSelected = dateStr === value;
+                const isToday = dateStr === todayStr;
+
+                return (
+                  <button
+                    className={cn(
+                      'flex h-8 w-full items-center justify-center rounded-lg text-sm transition',
+                      isSelected
+                        ? 'bg-brand font-semibold text-white'
+                        : isToday
+                          ? 'border border-brand font-semibold text-brand hover:bg-indigo-50'
+                          : 'text-zinc-700 hover:bg-zinc-100 hover:text-zinc-900',
+                    )}
+                    key={day}
+                    onClick={() => {
+                      onChange(dateStr);
+                      setIsOpen(false);
+                    }}
+                    type="button"
+                  >
+                    {day}
+                  </button>
+                );
+              })}
+            </div>
+          </div>
+
+          <div className="flex items-center justify-between border-t border-zinc-100 px-4 py-2.5">
+            <button
+              className="text-xs font-medium text-zinc-500 transition hover:text-danger"
+              onClick={() => {
+                onChange('');
+                setIsOpen(false);
+              }}
+              type="button"
+            >
+              Clear
+            </button>
+            <button
+              className="text-xs font-medium text-brand transition hover:text-indigo-500"
+              onClick={() => {
+                const t = new Date();
+                setViewDate(new Date(t.getFullYear(), t.getMonth(), 1));
+                onChange(toDateString(t));
+                setIsOpen(false);
+              }}
+              type="button"
+            >
+              Today
+            </button>
+          </div>
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function CalendarIcon() {
+  return (
+    <svg
+      aria-hidden="true"
+      className="size-4 shrink-0 text-zinc-400"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={1.5}
+      viewBox="0 0 24 24"
+    >
+      <path
+        d="M6.75 3v2.25M17.25 3v2.25M3 18.75V7.5a2.25 2.25 0 0 1 2.25-2.25h13.5A2.25 2.25 0 0 1 21 7.5v11.25m-18 0A2.25 2.25 0 0 0 5.25 21h13.5A2.25 2.25 0 0 0 21 18.75m-18 0v-7.5A2.25 2.25 0 0 1 5.25 9h13.5A2.25 2.25 0 0 1 21 11.25v7.5"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+    </svg>
+  );
+}
+
+function ChevronLeftIcon() {
+  return (
+    <svg
+      aria-hidden="true"
+      className="size-4"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      viewBox="0 0 24 24"
+    >
+      <path d="M15.75 19.5 8.25 12l7.5-7.5" strokeLinecap="round" strokeLinejoin="round" />
+    </svg>
+  );
+}
+
+function ChevronRightIcon() {
+  return (
+    <svg
+      aria-hidden="true"
+      className="size-4"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      viewBox="0 0 24 24"
+    >
+      <path d="m8.25 4.5 7.5 7.5-7.5 7.5" strokeLinecap="round" strokeLinejoin="round" />
+    </svg>
+  );
+}
diff --git a/app/src/shared/ui/date-picker/index.ts b/app/src/shared/ui/date-picker/index.ts
new file mode 100644
index 0000000..a4eb7f5
--- /dev/null
+++ b/app/src/shared/ui/date-picker/index.ts
@@ -0,0 +1 @@
+export { DatePicker } from './DatePicker';
diff --git a/app/src/shared/ui/empty-state/EmptyState.tsx b/app/src/shared/ui/empty-state/EmptyState.tsx
index 696521a..610d362 100644
--- a/app/src/shared/ui/empty-state/EmptyState.tsx
+++ b/app/src/shared/ui/empty-state/EmptyState.tsx
@@ -6,6 +6,8 @@ type EmptyStateProps = {
   className?: string;
   description: string;
   onAction?: () => void;
+  onSecondAction?: () => void;
+  secondActionLabel?: string;
   title: string;
 };
 
@@ -14,6 +16,8 @@ export function EmptyState({
   className,
   description,
   onAction,
+  onSecondAction,
+  secondActionLabel,
   title,
 }: EmptyStateProps) {
   return (
@@ -26,9 +30,14 @@ export function EmptyState({
       <h2 className="text-lg font-semibold text-zinc-950">{title}</h2>
       <p className="mx-auto mt-2 max-w-md text-sm text-zinc-600">{description}</p>
       {actionLabel && onAction ? (
-        <Button className="mt-5" onClick={onAction}>
-          {actionLabel}
-        </Button>
+        <div className="mt-5 flex justify-center gap-2">
+          <Button onClick={onAction}>{actionLabel}</Button>
+          {secondActionLabel && onSecondAction ? (
+            <Button onClick={onSecondAction} variant="secondary">
+              {secondActionLabel}
+            </Button>
+          ) : null}
+        </div>
       ) : null}
     </div>
   );
diff --git a/app/src/shared/ui/modal/Modal.tsx b/app/src/shared/ui/modal/Modal.tsx
index a46560e..55f850f 100644
--- a/app/src/shared/ui/modal/Modal.tsx
+++ b/app/src/shared/ui/modal/Modal.tsx
@@ -38,7 +38,7 @@ export function Modal({ children, description, footer, isOpen, onClose, title }:
 
   return (
     <div
-      className="fixed inset-0 z-50 grid place-items-center bg-zinc-950/40 p-4"
+      className="fixed inset-0 z-50 grid place-items-end bg-zinc-950/40 p-0 sm:place-items-center sm:p-4"
       onMouseDown={(event) => {
         if (event.target === event.currentTarget) {
           onClose();
@@ -49,10 +49,10 @@ export function Modal({ children, description, footer, isOpen, onClose, title }:
         aria-describedby={description ? descriptionId : undefined}
         aria-labelledby={titleId}
         aria-modal="true"
-        className="w-full max-w-lg rounded-lg bg-white shadow-xl"
+        className="max-h-[92vh] w-full overflow-y-auto rounded-t-lg bg-white shadow-xl sm:max-w-lg sm:rounded-lg"
         role="dialog"
       >
-        <header className="flex items-start justify-between gap-3 border-b border-zinc-200 p-5">
+        <header className="flex items-start justify-between gap-3 border-b border-zinc-200 p-4 sm:p-5">
           <div>
             <h2 className="text-lg font-semibold text-zinc-950" id={titleId}>
               {title}
@@ -67,8 +67,8 @@ export function Modal({ children, description, footer, isOpen, onClose, title }:
             X
           </Button>
         </header>
-        <div className="p-5">{children}</div>
-        {footer ? <footer className="border-t border-zinc-200 p-5">{footer}</footer> : null}
+        <div className="p-4 sm:p-5">{children}</div>
+        {footer ? <footer className="border-t border-zinc-200 p-4 sm:p-5">{footer}</footer> : null}
       </section>
     </div>
   );
diff --git a/app/src/shared/ui/page-header/PageHeader.tsx b/app/src/shared/ui/page-header/PageHeader.tsx
index 714bc71..a440bed 100644
--- a/app/src/shared/ui/page-header/PageHeader.tsx
+++ b/app/src/shared/ui/page-header/PageHeader.tsx
@@ -9,13 +9,15 @@ type PageHeaderProps = {
 export function PageHeader({ actions, description, title }: PageHeaderProps) {
   return (
     <div className="flex flex-col gap-4 md:flex-row md:items-start md:justify-between">
-      <div>
+      <div className="min-w-0">
         <h1 className="text-2xl font-semibold text-zinc-950">{title}</h1>
         {description ? (
           <p className="mt-2 max-w-2xl text-sm leading-6 text-zinc-600">{description}</p>
         ) : null}
       </div>
-      {actions ? <div className="flex flex-wrap items-center gap-2">{actions}</div> : null}
+      {actions ? (
+        <div className="flex w-full flex-wrap items-center gap-2 md:w-auto">{actions}</div>
+      ) : null}
     </div>
   );
 }
diff --git a/app/src/shared/ui/select/Select.tsx b/app/src/shared/ui/select/Select.tsx
index 32e8fa0..b36122c 100644
--- a/app/src/shared/ui/select/Select.tsx
+++ b/app/src/shared/ui/select/Select.tsx
@@ -1,44 +1,159 @@
-import type { SelectHTMLAttributes } from 'react';
-import { useId } from 'react';
+import { useEffect, useId, useRef, useState } from 'react';
 
 import { cn } from '@shared/lib/classnames/cn';
 
-type SelectProps = SelectHTMLAttributes<HTMLSelectElement> & {
+export type SelectOption = {
+  label: string;
+  value: string;
+};
+
+type SelectProps = {
+  disabled?: boolean;
   error?: string;
   hint?: string;
+  id?: string;
   label?: string;
+  onChange: (value: string) => void;
+  options: SelectOption[];
+  value: string;
 };
 
-export function Select({ children, className, error, hint, id, label, ...props }: SelectProps) {
+export function Select({
+  disabled,
+  error,
+  hint,
+  id,
+  label,
+  onChange,
+  options,
+  value,
+}: SelectProps) {
   const generatedId = useId();
   const selectId = id ?? generatedId;
-  const descriptionId = `${selectId}-description`;
   const description = error ?? hint;
 
+  const [isOpen, setIsOpen] = useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const selectedOption = options.find((opt) => opt.value === value);
+
+  useEffect(() => {
+    if (!isOpen) return;
+
+    function handlePointerDown(e: PointerEvent) {
+      if (!containerRef.current?.contains(e.target as Node)) {
+        setIsOpen(false);
+      }
+    }
+
+    function handleKeyDown(e: KeyboardEvent) {
+      if (e.key === 'Escape') setIsOpen(false);
+    }
+
+    document.addEventListener('pointerdown', handlePointerDown);
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('pointerdown', handlePointerDown);
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [isOpen]);
+
   return (
-    <label className="grid gap-2 text-sm font-medium text-zinc-700" htmlFor={selectId}>
-      {label ? <span>{label}</span> : null}
-      <select
-        aria-describedby={description ? descriptionId : undefined}
+    <div className="relative grid gap-2 text-sm font-medium text-zinc-700" ref={containerRef}>
+      {label ? <span id={`${selectId}-label`}>{label}</span> : null}
+
+      <button
+        aria-expanded={isOpen}
+        aria-haspopup="listbox"
         aria-invalid={Boolean(error)}
+        aria-labelledby={label ? `${selectId}-label` : undefined}
         className={cn(
-          'h-10 rounded-md border border-zinc-200 bg-white px-3 text-sm text-zinc-900 outline-none transition focus:border-brand focus:ring-2 focus:ring-indigo-100 disabled:cursor-not-allowed disabled:bg-zinc-100 disabled:text-zinc-500',
+          'flex h-10 w-full items-center justify-between gap-2 rounded-md border border-zinc-200 bg-white px-3 text-left text-sm text-zinc-900 outline-none transition hover:border-zinc-300 focus:border-brand focus:ring-2 focus:ring-indigo-100',
+          disabled && 'cursor-not-allowed bg-zinc-100 text-zinc-500 hover:border-zinc-200',
           error && 'border-danger focus:border-danger focus:ring-red-100',
-          className,
         )}
-        id={selectId}
-        {...props}
+        disabled={disabled}
+        onClick={() => setIsOpen((o) => !o)}
+        type="button"
       >
-        {children}
-      </select>
+        <span className="truncate">{selectedOption?.label ?? 'Select...'}</span>
+        <ChevronDownIcon
+          className={cn(
+            'size-4 shrink-0 text-zinc-400 transition-transform duration-150',
+            isOpen && 'rotate-180',
+          )}
+        />
+      </button>
+
       {description ? (
-        <span
-          className={cn('text-xs font-normal text-zinc-500', error && 'text-danger')}
-          id={descriptionId}
-        >
+        <span className={cn('text-xs font-normal text-zinc-500', error && 'text-danger')}>
           {description}
         </span>
       ) : null}
-    </label>
+
+      {isOpen && !disabled ? (
+        <div
+          className="absolute top-full z-50 mt-1.5 max-h-64 w-full min-w-max overflow-auto rounded-xl border border-zinc-200 bg-white p-1 shadow-xl"
+          role="listbox"
+        >
+          {options.map((option) => {
+            const isSelected = option.value === value;
+            return (
+              <button
+                aria-selected={isSelected}
+                className={cn(
+                  'flex w-full items-center gap-2 rounded-lg px-3 py-2 text-left text-sm transition',
+                  isSelected
+                    ? 'bg-indigo-50 font-medium text-brand'
+                    : 'text-zinc-700 hover:bg-zinc-50 hover:text-zinc-900',
+                )}
+                key={option.value}
+                onClick={() => {
+                  onChange(option.value);
+                  setIsOpen(false);
+                }}
+                role="option"
+                type="button"
+              >
+                <CheckIcon
+                  className={cn('size-3.5 shrink-0', isSelected ? 'text-brand' : 'invisible')}
+                />
+                {option.label}
+              </button>
+            );
+          })}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function ChevronDownIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-hidden="true"
+      className={className}
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      viewBox="0 0 24 24"
+    >
+      <path d="m6 9 6 6 6-6" strokeLinecap="round" strokeLinejoin="round" />
+    </svg>
+  );
+}
+
+function CheckIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-hidden="true"
+      className={className}
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2.5}
+      viewBox="0 0 24 24"
+    >
+      <path d="m4.5 12.75 6 6 9-13.5" strokeLinecap="round" strokeLinejoin="round" />
+    </svg>
   );
 }
diff --git a/app/src/shared/ui/select/index.ts b/app/src/shared/ui/select/index.ts
index 205709b..95658d5 100644
--- a/app/src/shared/ui/select/index.ts
+++ b/app/src/shared/ui/select/index.ts
@@ -1 +1,2 @@
 export { Select } from './Select';
+export type { SelectOption } from './Select';
diff --git a/app/src/widgets/app-layout/ui/AppLayout.tsx b/app/src/widgets/app-layout/ui/AppLayout.tsx
index fa57984..24d7725 100644
--- a/app/src/widgets/app-layout/ui/AppLayout.tsx
+++ b/app/src/widgets/app-layout/ui/AppLayout.tsx
@@ -24,14 +24,14 @@ export function AppLayout({ actions, children }: AppLayoutProps) {
   return (
     <div className="min-h-screen bg-slate-50">
       <header className="border-b border-zinc-200 bg-white">
-        <div className="mx-auto flex max-w-6xl items-center justify-between px-4 py-4">
-          <div>
+        <div className="mx-auto flex max-w-6xl flex-col gap-4 px-4 py-4 md:flex-row md:items-center md:justify-between">
+          <div className="min-w-0">
             <p className="text-xs font-semibold uppercase tracking-wide text-brand">
               {appConfig.name}
             </p>
             <p className="text-sm text-zinc-600">{appConfig.description}</p>
           </div>
-          <nav className="flex items-center gap-2 text-sm">
+          <nav className="flex w-full flex-wrap items-center gap-2 text-sm md:w-auto md:justify-end">
             <Badge variant={syncBadge.variant}>{syncBadge.label}</Badge>
             <NavLink
               className="rounded-md px-3 py-2 text-zinc-700 hover:bg-zinc-100"
diff --git a/app/src/widgets/dashboard-analytics/ui/DashboardAnalytics.tsx b/app/src/widgets/dashboard-analytics/ui/DashboardAnalytics.tsx
index ba2f598..0c2135a 100644
--- a/app/src/widgets/dashboard-analytics/ui/DashboardAnalytics.tsx
+++ b/app/src/widgets/dashboard-analytics/ui/DashboardAnalytics.tsx
@@ -6,6 +6,7 @@ import {
   type CategoryStats,
   type ChartId,
 } from '@features/analyze-transactions';
+import { getTransactionCurrencyOptions } from '@features/filter-transactions';
 import { Button } from '@shared/ui/button';
 import { Card } from '@shared/ui/card';
 import { EmptyState } from '@shared/ui/empty-state';
@@ -243,7 +244,7 @@ function ChartSlot({
 
   return (
     <Card
-      className={isWide ? 'min-h-[420px]' : 'min-h-[360px]'}
+      className={isWide ? 'min-h-[360px] md:min-h-[420px]' : 'min-h-[320px] md:min-h-[360px]'}
       onDragOver={(event) => event.preventDefault()}
       onDrop={(event) => {
         const droppedChartId = event.dataTransfer.getData('text/plain');
@@ -273,7 +274,7 @@ function ChartSlot({
           </Button>
         </div>
       </div>
-      <div className={isWide ? 'h-80' : 'h-72'}>
+      <div className={isWide ? 'h-64 md:h-80' : 'h-56 md:h-72'}>
         <ResponsiveContainer height="100%" width="100%">
           {renderChart({ categoryStats, chartId, dailyExpenseStats, monthlyStats })}
         </ResponsiveContainer>
@@ -310,7 +311,40 @@ function ChartDragPreview({
 }
 
 export function DashboardAnalytics({ transactions }: DashboardAnalyticsProps) {
-  const { categoryStats, monthlyStats, source } = useAnalyticsStats(transactions);
+  const availableCurrencies = useMemo(
+    () => getTransactionCurrencyOptions(transactions),
+    [transactions],
+  );
+  const isMultiCurrency = availableCurrencies.length > 1;
+
+  const [activeCurrency, setActiveCurrency] = useState<string>(() => {
+    const stored = localStorageService.get('analyticsActiveCurrency');
+    return stored ?? availableCurrencies[0] ?? '';
+  });
+
+  const displayCurrency = useMemo(
+    () =>
+      availableCurrencies.includes(activeCurrency)
+        ? activeCurrency
+        : (availableCurrencies[0] ?? ''),
+    [availableCurrencies, activeCurrency],
+  );
+
+  function handleCurrencyChange(currency: string) {
+    setActiveCurrency(currency);
+    localStorageService.set('analyticsActiveCurrency', currency);
+  }
+
+  const filteredTransactions = useMemo(
+    () =>
+      isMultiCurrency ? transactions.filter((t) => t.currency === displayCurrency) : transactions,
+    [transactions, isMultiCurrency, displayCurrency],
+  );
+
+  const { categoryStats, monthlyStats, source } = useAnalyticsStats(
+    filteredTransactions,
+    isMultiCurrency,
+  );
   const [chartSlots, setChartSlots] = useState<ChartSlots>(() =>
     parseChartSlots(localStorageService.get('analyticsChartSlots')),
   );
@@ -319,7 +353,10 @@ export function DashboardAnalytics({ transactions }: DashboardAnalyticsProps) {
   );
   const [isPickerOpen, setIsPickerOpen] = useState(false);
   const [selectedSlotIndex, setSelectedSlotIndex] = useState<0 | 1>(0);
-  const dailyExpenseStats = useMemo(() => calculateDailyExpenseStats(transactions), [transactions]);
+  const dailyExpenseStats = useMemo(
+    () => calculateDailyExpenseStats(filteredTransactions),
+    [filteredTransactions],
+  );
 
   function updateChartSlot(slotIndex: 0 | 1, chartId: ChartId) {
     const nextSlots: ChartSlots =
@@ -366,9 +403,29 @@ export function DashboardAnalytics({ transactions }: DashboardAnalyticsProps) {
           <p className="text-sm font-medium text-zinc-500">
             {source === 'google-sheets' ? 'Google Sheets analytics' : 'Local analytics'}
           </p>
-          <Button onClick={() => setIsPickerOpen((current) => !current)} variant="secondary">
-            {isPickerOpen ? 'Hide charts' : 'Choose charts'}
-          </Button>
+          <div className="flex flex-wrap items-center gap-2">
+            {isMultiCurrency ? (
+              <div className="flex gap-1">
+                {availableCurrencies.map((currency) => (
+                  <Button
+                    key={currency}
+                    onClick={() => handleCurrencyChange(currency)}
+                    size="sm"
+                    variant={currency === displayCurrency ? 'secondary' : 'ghost'}
+                  >
+                    {currency}
+                  </Button>
+                ))}
+              </div>
+            ) : null}
+            <Button
+              className="w-full sm:w-auto"
+              onClick={() => setIsPickerOpen((current) => !current)}
+              variant="secondary"
+            >
+              {isPickerOpen ? 'Hide charts' : 'Choose charts'}
+            </Button>
+          </div>
         </div>
         {wideChartId ? (
           <ChartSlot
@@ -406,7 +463,7 @@ export function DashboardAnalytics({ transactions }: DashboardAnalyticsProps) {
         )}
       </div>
       {isPickerOpen ? (
-        <aside className="fixed inset-x-4 bottom-4 top-20 z-40 overflow-y-auto xl:inset-x-auto xl:right-4 xl:w-80">
+        <aside className="fixed inset-x-3 bottom-3 top-16 z-40 overflow-y-auto sm:inset-x-4 sm:bottom-4 sm:top-20 xl:inset-x-auto xl:right-4 xl:w-80">
           <Card className="min-h-full">
             <div className="mb-4">
               <div className="flex items-start justify-between gap-3">
@@ -453,7 +510,7 @@ export function DashboardAnalytics({ transactions }: DashboardAnalyticsProps) {
                     dailyExpenseStats={dailyExpenseStats}
                     monthlyStats={monthlyStats}
                   />
-                  <div className="mt-3 flex flex-wrap gap-2">
+                  <div className="mt-3 grid grid-cols-3 gap-2">
                     <Button onClick={() => updateChartSlot(0, chart.id)} size="sm" variant="ghost">
                       Slot 1
                     </Button>
diff --git a/app/src/widgets/transactions-history/ui/TransactionsHistory.tsx b/app/src/widgets/transactions-history/ui/TransactionsHistory.tsx
index 23894d9..07cc494 100644
--- a/app/src/widgets/transactions-history/ui/TransactionsHistory.tsx
+++ b/app/src/widgets/transactions-history/ui/TransactionsHistory.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 
 import type { Transaction } from '@entities/transaction';
 import {
@@ -6,13 +6,16 @@ import {
   filterTransactions,
   getTransactionContainerOptions,
   getTransactionCategoryOptions,
+  getTransactionCurrencyOptions,
   type TransactionFilters,
 } from '@features/filter-transactions';
 import { Badge, type BadgeVariant } from '@shared/ui/badge';
 import { Button } from '@shared/ui/button';
 import { Card } from '@shared/ui/card';
+import { DatePicker } from '@shared/ui/date-picker';
 import { EmptyState } from '@shared/ui/empty-state';
 import { Input } from '@shared/ui/input';
+import { Select } from '@shared/ui/select';
 import { Skeleton } from '@shared/ui/skeleton';
 
 type TransactionsHistoryProps = {
@@ -54,24 +57,6 @@ function formatSyncStatus(status: Transaction['syncStatus']) {
   return status[0].toUpperCase() + status.slice(1);
 }
 
-function formatDateLabel(value: string) {
-  if (!value) {
-    return 'dd.mm.yyyy';
-  }
-
-  const [year, month, day] = value.split('-');
-
-  return `${day}.${month}.${year}`;
-}
-
-function toDateValue(date: Date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-
-  return `${year}-${month}-${day}`;
-}
-
 function useOutsideClose(isOpen: boolean, onClose: () => void) {
   const ref = useRef<HTMLDivElement>(null);
 
@@ -100,6 +85,7 @@ function hasActiveFilters(filters: TransactionFilters) {
     filters.amountTo ||
     filters.category ||
     filters.container ||
+    filters.currency ||
     filters.dateFrom ||
     filters.dateTo ||
     filters.kind !== 'all' ||
@@ -136,191 +122,6 @@ function TransactionsHistorySkeleton() {
   );
 }
 
-type FilterOption = {
-  label: string;
-  value: string;
-};
-
-type FilterSelectProps = {
-  id: string;
-  label: string;
-  onChange: (value: string) => void;
-  options: FilterOption[];
-  value: string;
-};
-
-function FilterSelect({ id, label, onChange, options, value }: FilterSelectProps) {
-  const [isOpen, setIsOpen] = useState(false);
-  const selectedOption = options.find((option) => option.value === value) ?? options[0];
-  const wrapperRef = useOutsideClose(isOpen, () => setIsOpen(false));
-
-  return (
-    <div className="relative grid gap-2 text-sm font-medium text-zinc-700" ref={wrapperRef}>
-      <span id={`${id}-label`}>{label}</span>
-      <button
-        aria-expanded={isOpen}
-        aria-labelledby={`${id}-label`}
-        className="flex h-10 items-center justify-between gap-3 rounded-md border border-zinc-200 bg-white px-3 text-left text-sm text-zinc-900 shadow-sm outline-none transition hover:border-zinc-300 focus:border-brand focus:ring-2 focus:ring-indigo-100"
-        onClick={() => setIsOpen((current) => !current)}
-        type="button"
-      >
-        <span className="truncate">{selectedOption.label}</span>
-        <span className="text-xs text-zinc-400">⌄</span>
-      </button>
-      {isOpen ? (
-        <div className="absolute top-full z-20 mt-2 max-h-64 w-full min-w-44 overflow-auto rounded-md border border-zinc-200 bg-white p-1 shadow-lg">
-          {options.map((option) => (
-            <button
-              className={
-                option.value === value
-                  ? 'flex w-full rounded px-3 py-2 text-left text-sm font-medium text-brand'
-                  : 'flex w-full rounded px-3 py-2 text-left text-sm text-zinc-700 hover:bg-zinc-50'
-              }
-              key={option.value}
-              onClick={() => {
-                onChange(option.value);
-                setIsOpen(false);
-              }}
-              type="button"
-            >
-              {option.label}
-            </button>
-          ))}
-        </div>
-      ) : null}
-    </div>
-  );
-}
-
-type DateFilterFieldProps = {
-  id: string;
-  label: string;
-  onChange: (value: string) => void;
-  value: string;
-};
-
-function DateFilterField({ id, label, onChange, value }: DateFilterFieldProps) {
-  const selectedDate = value ? new Date(`${value}T00:00:00`) : new Date();
-  const [isOpen, setIsOpen] = useState(false);
-  const [visibleMonth, setVisibleMonth] = useState(
-    new Date(selectedDate.getFullYear(), selectedDate.getMonth(), 1),
-  );
-  const wrapperRef = useOutsideClose(isOpen, () => setIsOpen(false));
-  const monthLabel = visibleMonth.toLocaleDateString('en-US', {
-    month: 'long',
-    year: 'numeric',
-  });
-  const firstWeekday = (visibleMonth.getDay() + 6) % 7;
-  const daysInMonth = new Date(
-    visibleMonth.getFullYear(),
-    visibleMonth.getMonth() + 1,
-    0,
-  ).getDate();
-  const calendarDays = [
-    ...Array.from({ length: firstWeekday }, () => null),
-    ...Array.from(
-      { length: daysInMonth },
-      (_, index) => new Date(visibleMonth.getFullYear(), visibleMonth.getMonth(), index + 1),
-    ),
-  ];
-
-  function moveMonth(direction: -1 | 1) {
-    setVisibleMonth(
-      (current) => new Date(current.getFullYear(), current.getMonth() + direction, 1),
-    );
-  }
-
-  return (
-    <div className="relative grid gap-2 text-sm font-medium text-zinc-700" ref={wrapperRef}>
-      <span id={`${id}-label`}>{label}</span>
-      <button
-        aria-expanded={isOpen}
-        aria-labelledby={`${id}-label`}
-        className="flex h-10 items-center justify-between gap-3 rounded-md border border-zinc-200 bg-white px-3 text-left text-sm text-zinc-900 shadow-sm outline-none transition hover:border-zinc-300 focus:border-brand focus:ring-2 focus:ring-indigo-100"
-        onClick={() => setIsOpen((current) => !current)}
-        type="button"
-      >
-        <span className={value ? 'text-zinc-900' : 'text-zinc-400'}>{formatDateLabel(value)}</span>
-        <span className="text-zinc-400">▦</span>
-      </button>
-      {isOpen ? (
-        <div className="absolute top-full z-30 mt-2 w-72 rounded-lg border border-zinc-200 bg-white p-3 shadow-xl">
-          <div className="flex items-center justify-between">
-            <button
-              className="rounded-md px-2 py-1 text-zinc-500 hover:bg-zinc-100"
-              onClick={() => moveMonth(-1)}
-              type="button"
-            >
-              ←
-            </button>
-            <p className="text-sm font-semibold text-zinc-950">{monthLabel}</p>
-            <button
-              className="rounded-md px-2 py-1 text-zinc-500 hover:bg-zinc-100"
-              onClick={() => moveMonth(1)}
-              type="button"
-            >
-              →
-            </button>
-          </div>
-          <div className="mt-3 grid grid-cols-7 gap-1 text-center text-xs font-semibold text-zinc-400">
-            {['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'].map((day) => (
-              <span key={day}>{day}</span>
-            ))}
-          </div>
-          <div className="mt-2 grid grid-cols-7 gap-1">
-            {calendarDays.map((date, index) =>
-              date ? (
-                <button
-                  className={
-                    toDateValue(date) === value
-                      ? 'h-8 rounded-md bg-brand text-sm font-semibold text-white'
-                      : 'h-8 rounded-md text-sm text-zinc-700 hover:bg-indigo-50 hover:text-brand'
-                  }
-                  key={toDateValue(date)}
-                  onClick={() => {
-                    onChange(toDateValue(date));
-                    setIsOpen(false);
-                  }}
-                  type="button"
-                >
-                  {date.getDate()}
-                </button>
-              ) : (
-                <span key={`empty-${index}`} />
-              ),
-            )}
-          </div>
-          <div className="mt-3 flex justify-between border-t border-zinc-100 pt-3">
-            <button
-              className="text-sm font-medium text-zinc-500 hover:text-danger"
-              onClick={() => {
-                onChange('');
-                setIsOpen(false);
-              }}
-              type="button"
-            >
-              Clear
-            </button>
-            <button
-              className="text-sm font-medium text-brand"
-              onClick={() => {
-                const today = new Date();
-
-                setVisibleMonth(new Date(today.getFullYear(), today.getMonth(), 1));
-                onChange(toDateValue(today));
-                setIsOpen(false);
-              }}
-              type="button"
-            >
-              Today
-            </button>
-          </div>
-        </div>
-      ) : null}
-    </div>
-  );
-}
-
 type RowActionsProps = {
   onDelete: () => void | Promise<void>;
   onEdit: () => void;
@@ -380,6 +181,17 @@ function CommentCell({ value }: { value?: string }) {
   );
 }
 
+function TransactionField({ children, label }: { children: ReactNode; label: string }) {
+  return (
+    <div className="flex items-start justify-between gap-3 md:block">
+      <span className="shrink-0 text-xs font-semibold uppercase text-zinc-400 md:hidden">
+        {label}
+      </span>
+      <div className="min-w-0 text-right md:text-left">{children}</div>
+    </div>
+  );
+}
+
 export function TransactionsHistory({
   containersEnabled = false,
   error,
@@ -403,6 +215,10 @@ export function TransactionsHistory({
     () => getTransactionContainerOptions(transactions),
     [transactions],
   );
+  const currencyOptions = useMemo(
+    () => getTransactionCurrencyOptions(transactions),
+    [transactions],
+  );
   const filteredTransactions = useMemo(
     () => filterTransactions(transactions, filters),
     [filters, transactions],
@@ -443,6 +259,8 @@ export function TransactionsHistory({
         actionLabel="Create transaction"
         description="Transactions from Ledger will appear here after the first sync."
         onAction={onCreateTransaction}
+        onSecondAction={() => void onRefresh()}
+        secondActionLabel="Refresh"
         title="No transactions yet"
       />
     );
@@ -460,9 +278,10 @@ export function TransactionsHistory({
           {error ? <p className="mt-1 text-sm text-danger">{error}</p> : null}
           {syncWarning ? <p className="mt-1 text-sm text-amber-700">{syncWarning}</p> : null}
         </div>
-        <div className="flex flex-wrap gap-2">
+        <div className="grid grid-cols-2 gap-2 sm:flex sm:flex-wrap">
           {hasPendingSync ? (
             <Button
+              className="col-span-2 sm:col-span-1"
               disabled={isSyncing}
               isLoading={isSyncing}
               onClick={() => void onRetrySync()}
@@ -471,7 +290,12 @@ export function TransactionsHistory({
               Retry sync
             </Button>
           ) : null}
-          <Button disabled={isLoading} onClick={() => void onRefresh()} variant="secondary">
+          <Button
+            className={hasPendingSync ? undefined : 'col-span-2 sm:col-span-1'}
+            disabled={isLoading}
+            onClick={() => void onRefresh()}
+            variant="secondary"
+          >
             Refresh
           </Button>
         </div>
@@ -486,7 +310,7 @@ export function TransactionsHistory({
             placeholder="Comment, method, category"
             value={filters.query}
           />
-          <FilterSelect
+          <Select
             id="transactions-kind"
             label="Type"
             onChange={(kind) => updateFilters({ kind: kind as TransactionFilters['kind'] })}
@@ -497,7 +321,7 @@ export function TransactionsHistory({
             ]}
             value={filters.kind}
           />
-          <FilterSelect
+          <Select
             id="transactions-category"
             label="Category"
             onChange={(category) => updateFilters({ category })}
@@ -508,25 +332,32 @@ export function TransactionsHistory({
             value={filters.category}
           />
           <Button
+            className="w-full"
             onClick={() => setIsAdvancedFiltersOpen((current) => !current)}
             type="button"
             variant="secondary"
           >
             {isAdvancedFiltersOpen ? 'Hide filters' : 'More filters'}
           </Button>
-          <Button disabled={!isFiltered} onClick={clearFilters} type="button" variant="ghost">
+          <Button
+            className="w-full"
+            disabled={!isFiltered}
+            onClick={clearFilters}
+            type="button"
+            variant="ghost"
+          >
             Clear
           </Button>
         </div>
         {isAdvancedFiltersOpen ? (
-          <div className="mt-4 grid gap-4 rounded-md border border-zinc-200 bg-white p-4 lg:grid-cols-[repeat(4,minmax(130px,1fr))]">
-            <DateFilterField
+          <div className="mt-4 grid gap-4 rounded-md border border-zinc-200 bg-white p-4 sm:grid-cols-2 lg:grid-cols-[repeat(4,minmax(130px,1fr))]">
+            <DatePicker
               id="transactions-date-from"
               label="Date from"
               onChange={(dateFrom) => updateFilters({ dateFrom })}
               value={filters.dateFrom}
             />
-            <DateFilterField
+            <DatePicker
               id="transactions-date-to"
               label="Date to"
               onChange={(dateTo) => updateFilters({ dateTo })}
@@ -546,8 +377,18 @@ export function TransactionsHistory({
               placeholder="1000"
               value={filters.amountTo}
             />
+            <Select
+              id="transactions-currency"
+              label="Currency"
+              onChange={(currency) => updateFilters({ currency })}
+              options={[
+                { label: 'All currencies', value: '' },
+                ...currencyOptions.map((currency) => ({ label: currency, value: currency })),
+              ]}
+              value={filters.currency}
+            />
             {containersEnabled ? (
-              <FilterSelect
+              <Select
                 id="transactions-container"
                 label="Container"
                 onChange={(container) => updateFilters({ container })}
@@ -558,7 +399,7 @@ export function TransactionsHistory({
                 value={filters.container}
               />
             ) : null}
-            <FilterSelect
+            <Select
               id="transactions-sync-status"
               label="Sync status"
               onChange={(syncStatus) =>
@@ -614,34 +455,48 @@ export function TransactionsHistory({
               <div
                 className={
                   transaction.deletedAt
-                    ? 'grid gap-2 bg-zinc-50 px-5 py-4 text-sm opacity-70 md:grid-cols-[110px_78px_1fr_110px_120px_1fr_110px_86px_104px] md:items-center md:gap-3'
-                    : 'grid gap-2 px-5 py-4 text-sm md:grid-cols-[110px_78px_1fr_110px_120px_1fr_110px_86px_104px] md:items-center md:gap-3'
+                    ? 'grid gap-3 bg-zinc-50 px-4 py-4 text-sm opacity-70 md:grid-cols-[110px_78px_1fr_110px_120px_1fr_110px_86px_104px] md:items-center md:gap-3 md:px-5'
+                    : 'grid gap-3 px-4 py-4 text-sm md:grid-cols-[110px_78px_1fr_110px_120px_1fr_110px_86px_104px] md:items-center md:gap-3 md:px-5'
                 }
                 key={transaction.id}
               >
-                <div className="text-zinc-500">{transaction.date}</div>
-                <div className="font-medium text-zinc-700">{formatKind(transaction.kind)}</div>
-                <div className="font-medium text-zinc-950">{transaction.categoryName}</div>
-                <div
-                  className={
-                    transaction.kind === 'income'
-                      ? 'font-semibold text-emerald-600 md:text-right'
-                      : 'font-semibold text-danger md:text-right'
-                  }
-                >
-                  {formatMoney(transaction.signedAmount, transaction.currency)}
-                </div>
-                <div className="text-zinc-600">{transaction.paymentMethod || '-'}</div>
-                <CommentCell value={transaction.comment} />
-                <div className="text-zinc-600">{transaction.containerName || '-'}</div>
-                <div>
+                <TransactionField label="Date">
+                  <div className="text-zinc-500">{transaction.date}</div>
+                </TransactionField>
+                <TransactionField label="Type">
+                  <div className="font-medium text-zinc-700">{formatKind(transaction.kind)}</div>
+                </TransactionField>
+                <TransactionField label="Category">
+                  <div className="font-medium text-zinc-950">{transaction.categoryName}</div>
+                </TransactionField>
+                <TransactionField label="Amount">
+                  <div
+                    className={
+                      transaction.kind === 'income'
+                        ? 'font-semibold text-emerald-600 md:text-right'
+                        : 'font-semibold text-danger md:text-right'
+                    }
+                  >
+                    {formatMoney(transaction.signedAmount, transaction.currency)}
+                  </div>
+                </TransactionField>
+                <TransactionField label="Payment">
+                  <div className="text-zinc-600">{transaction.paymentMethod || '-'}</div>
+                </TransactionField>
+                <TransactionField label="Comment">
+                  <CommentCell value={transaction.comment} />
+                </TransactionField>
+                <TransactionField label="Container">
+                  <div className="text-zinc-600">{transaction.containerName || '-'}</div>
+                </TransactionField>
+                <TransactionField label="Status">
                   <div className="flex flex-wrap gap-1">
                     {transaction.deletedAt ? <Badge variant="neutral">Deleted</Badge> : null}
                     <Badge variant={syncStatusVariants[transaction.syncStatus]}>
                       {formatSyncStatus(transaction.syncStatus)}
                     </Badge>
                   </div>
-                </div>
+                </TransactionField>
                 <RowActions
                   onDelete={() => onDeleteTransaction(transaction.id)}
                   onEdit={() => onEditTransaction(transaction)}