diff --git a/packages/vlossom/src/components/vs-table/VsTable.vue b/packages/vlossom/src/components/vs-table/VsTable.vue
index 85a8d6c2c..77bab1ef2 100644
--- a/packages/vlossom/src/components/vs-table/VsTable.vue
+++ b/packages/vlossom/src/components/vs-table/VsTable.vue
@@ -99,7 +99,7 @@
 <script lang="ts">
 import { ComputedRef, PropType, Ref, computed, defineComponent, ref, toRefs, watch } from 'vue';
 import { getResponsiveProps, useColorScheme, useStyleSet } from '@/composables';
-import { useTableParams } from './composables/useTableParams';
+import { useTableParams } from './composables';
 import { VsComponent, type ColorScheme, LabelValue } from '@/declaration';
 import { utils } from '@/utils';
 import { DEFAULT_TABLE_ITEMS_PER_PAGE, DEFAULT_TABLE_PAGE_COUNT } from './constant';
diff --git a/packages/vlossom/src/components/vs-table/VsTableBody.vue b/packages/vlossom/src/components/vs-table/VsTableBody.vue
index 94c26860d..bcfa92c1f 100644
--- a/packages/vlossom/src/components/vs-table/VsTableBody.vue
+++ b/packages/vlossom/src/components/vs-table/VsTableBody.vue
@@ -70,12 +70,14 @@
 import draggable from 'vuedraggable/src/vuedraggable';
 import { computed, ComputedRef, defineComponent, PropType, ref, Ref, toRefs, watch, WritableComputedRef } from 'vue';
 import VsTableBodyRow from './VsTableBodyRow.vue';
-import { useTableSearch } from './composables/useTableSearch';
-import { useTableFilter } from './composables/useTableFilter';
-import { useTableSort } from './composables/useTableSort';
-import { useTableExpand } from './composables/useTableExpand';
-import { useTableSelect } from './composables/useTableSelect';
-import { useTablePagination } from './composables/useTablePagination';
+import {
+    useTableSearch,
+    useTableFilter,
+    useTableSort,
+    useTableExpand,
+    useTableSelect,
+    useTablePagination,
+} from './composables';
 import { VsIcon } from '@/icons';
 import { VsCheckboxNode } from '@/nodes';
 import { utils } from '@/utils';
diff --git a/packages/vlossom/src/components/vs-table/VsTableBodyRow.vue b/packages/vlossom/src/components/vs-table/VsTableBodyRow.vue
index 70574db93..6eb6ae9ff 100644
--- a/packages/vlossom/src/components/vs-table/VsTableBodyRow.vue
+++ b/packages/vlossom/src/components/vs-table/VsTableBodyRow.vue
@@ -60,6 +60,7 @@
 <script lang="ts">
 import { computed, ComputedRef, defineComponent, PropType, toRefs } from 'vue';
 import { ColorScheme, UIState } from '@/declaration';
+import { utils } from '@/utils';
 import { VsIcon } from '@/icons';
 import VsSkeleton from '@/components/vs-skeleton/VsSkeleton.vue';
 
@@ -96,7 +97,7 @@ export default defineComponent({
 
             return headers.value.map((header) => {
                 const { key } = header;
-                return { key, value: row[key] };
+                return { key, value: utils.object.get(row, key) };
             });
         }
 
diff --git a/packages/vlossom/src/components/vs-table/VsTableHeader.vue b/packages/vlossom/src/components/vs-table/VsTableHeader.vue
index ea7a26acd..e58a8ff50 100644
--- a/packages/vlossom/src/components/vs-table/VsTableHeader.vue
+++ b/packages/vlossom/src/components/vs-table/VsTableHeader.vue
@@ -41,7 +41,7 @@ import { defineComponent, PropType, toRefs } from 'vue';
 import { VsIcon } from '@/icons';
 import VsInput from '@/components/vs-input/VsInput.vue';
 import { SortType, type TableHeader } from './types';
-import { useSortableHeader } from './composables/useSortableHeader';
+import { useSortableHeader } from './composables';
 
 export default defineComponent({
     name: 'VsTableHeader',
diff --git a/packages/vlossom/src/components/vs-table/__tests__/vs-table.test.ts b/packages/vlossom/src/components/vs-table/__tests__/vs-table.test.ts
index 87898450b..85e10f5f6 100644
--- a/packages/vlossom/src/components/vs-table/__tests__/vs-table.test.ts
+++ b/packages/vlossom/src/components/vs-table/__tests__/vs-table.test.ts
@@ -42,7 +42,7 @@ const items: { [key: string]: any }[] = [
 ];
 
 describe('VsTable', () => {
-    describe('items / headers', () => {
+    describe('headers / items', () => {
         it('headers와 items 배열을 props로 할당하면 적절하게 table을 렌더할 수 있다', async () => {
             // given
             const wrapper: ReturnType<typeof mountComponent> = mount(VsTable, {
@@ -70,6 +70,33 @@ describe('VsTable', () => {
                 expect(td.text()).toBe(itemData);
             });
         });
+
+        it('path 형태의 header key를 설정해서 item을 만들 수 있다', () => {
+            // given
+            const pathHeaders: TableHeader[] = [{ label: 'Test', key: 'test.a.b', width: '7rem' }];
+
+            const pathItems: { [key: string]: any }[] = [
+                {
+                    test: {
+                        a: {
+                            b: 'value',
+                        },
+                    },
+                },
+            ];
+
+            // when
+            const wrapper: ReturnType<typeof mountComponent> = mount(VsTable, {
+                props: {
+                    headers: pathHeaders,
+                    items: pathItems,
+                },
+            });
+
+            // then
+            const tdElements = wrapper.findAll('tbody td');
+            expect(tdElements[0].text()).toBe('value');
+        });
     });
 
     describe('caption', () => {
diff --git a/packages/vlossom/src/components/vs-table/composables/__tests__/table-search-composable.test.ts b/packages/vlossom/src/components/vs-table/composables/__tests__/table-search-composable.test.ts
new file mode 100644
index 000000000..ef5f5ac6d
--- /dev/null
+++ b/packages/vlossom/src/components/vs-table/composables/__tests__/table-search-composable.test.ts
@@ -0,0 +1,223 @@
+import { describe, expect, it } from 'vitest';
+import { Ref, ref } from 'vue';
+import { useTableSearch } from './../table-search-composable';
+import { TableHeader, TableItem } from './../../types';
+
+describe('useTableSearch', () => {
+    describe('search targets', () => {
+        it('기본적으로 모든 header의 key는 검색 가능한 대상이다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'Name' },
+                { key: 'age', label: 'Age' },
+                { key: 'shopping', label: 'Shopping' },
+            ]);
+
+            // when
+            const { searchTargetKeys } = useTableSearch(headers, ref([]));
+
+            // then
+            expect(searchTargetKeys.value).toEqual(['id', 'name', 'age', 'shopping']);
+        });
+
+        it('searchable: false 설정으로 검색 대상에서 제외할 수 있다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'Name' },
+                { key: 'age', label: 'Age', searchable: false },
+                { key: 'shopping', label: 'Shopping', searchable: false },
+            ]);
+
+            // when
+            const { searchTargetKeys } = useTableSearch(headers, ref([]));
+
+            // then
+            expect(searchTargetKeys.value).toEqual(['id', 'name']);
+        });
+
+        it('기본 header의 key값 외에도 검색 가능한 key를 추가할 수 있다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'Name' },
+            ]);
+
+            // when
+            const { searchTargetKeys } = useTableSearch(headers, ref(['email', 'tel']));
+
+            // then
+            expect(searchTargetKeys.value).toEqual(['id', 'name', 'email', 'tel']);
+        });
+
+        it('path 형태의 key값을 설정할 수 있다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([
+                { key: 'id', label: 'ID' },
+                { key: 'shopping.item', label: 'Shopping Item' },
+                { key: 'shopping.ingredients', label: 'Ingredients' },
+                { key: 'shopping.ingredients.fat', label: 'Fat' },
+            ]);
+
+            // when
+            const { searchTargetKeys } = useTableSearch(headers, ref([]));
+
+            // then
+            expect(searchTargetKeys.value).toEqual([
+                'id',
+                'shopping.item',
+                'shopping.ingredients',
+                'shopping.ingredients.fat',
+            ]);
+        });
+    });
+
+    describe('getSearchedTableItems', () => {
+        const items: TableItem[] = [
+            {
+                id: 'item-1',
+                data: {
+                    name: 'John Doe',
+                    shopping: {
+                        date: '2021-09-01',
+                        items: [
+                            { item: 'Apple', price: 1.5, ingredients: { fat: '5%', sugar: '10%' } },
+                            { item: 'Banana', price: 2.5, ingredients: { fat: '10%', sugar: '4%' } },
+                        ],
+                    },
+                },
+            },
+            {
+                id: 'item-2',
+                data: {
+                    name: 'Jane Doe',
+                    shopping: {
+                        date: '2021-09-02',
+                        items: [
+                            { item: 'Orange', price: 3.5, ingredients: { fat: '15%', sugar: '8%' } },
+                            { item: 'Grapes', price: 4.5, ingredients: { fat: '20%', sugar: '12%' } },
+                        ],
+                    },
+                },
+            },
+            {
+                id: 'item-3',
+                data: {
+                    name: 'Alice',
+                    shopping: {
+                        date: '2021-09-03',
+                        items: [
+                            { item: 'Pineapple', price: 5.5, ingredients: { fat: '25%', sugar: '16%' } },
+                            { item: 'Mango', price: 6.5, ingredients: { fat: '30%', sugar: '20%' } },
+                        ],
+                    },
+                },
+            },
+            { id: 'item-4', data: { name: 'Bob', shopping: {} } },
+        ];
+
+        it('keyword가 빈 값이면 table items를 그대로 반환한다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'name', label: 'Name' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref(''));
+
+            // then
+            expect(result).toEqual(items);
+        });
+
+        it('keyword가 빈 스페이스로 이루어져 있으면 table items를 그대로 반환한다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'name', label: 'Name' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('   '));
+
+            // then
+            expect(result).toEqual(items);
+        });
+
+        it('keyword가 data에 포함되어 있으면 해당 아이템을 반환한다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'name', label: 'Name' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('Doe'));
+
+            // then
+            expect(result).length(2);
+            expect(result).toEqual([items[0], items[1]]);
+        });
+
+        it('검색 가능하지 않은 key(searchable: false)의 값은 검색되지 않는다', () => {
+            /// given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'name', label: 'Name', searchable: false }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('Doe'));
+
+            // then
+            expect(result).length(0);
+            expect(result).toEqual([]);
+        });
+
+        it('header에 없더라도 searchableKeys로 추가된 data를 검색할 수 있다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'name', label: 'Name' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref(['shopping']));
+            const result = getSearchedTableItems(items, ref('Banana'));
+
+            // then
+            expect(result).length(1);
+            expect(result).toEqual([items[0]]);
+        });
+
+        it('value가 object 형태일 때 keyword에 key 자체를 입력해도 검색된다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([
+                { key: 'name', label: 'Name' },
+                { key: 'shopping', label: 'Shopping' },
+            ]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('date'));
+
+            // then
+            expect(result).length(3);
+        });
+
+        it('key가 path 형태일 때도 검색이 가능하다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'shopping.items', label: 'Shopping Item' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('Banana'));
+
+            // then
+            expect(result).length(1);
+            expect(result).toEqual([items[0]]);
+        });
+
+        it('key값으로 등록되지 않은 path의 경우엔 검색되지 않는다', () => {
+            // given
+            const headers: Ref<TableHeader[]> = ref([{ key: 'shopping.items', label: 'Shopping Item' }]);
+
+            // when
+            const { getSearchedTableItems } = useTableSearch(headers, ref([]));
+            const result = getSearchedTableItems(items, ref('2021-09-01'));
+
+            // then
+            expect(result).length(0);
+        });
+    });
+});
diff --git a/packages/vlossom/src/components/vs-table/composables/index.ts b/packages/vlossom/src/components/vs-table/composables/index.ts
new file mode 100644
index 000000000..7e90e96e7
--- /dev/null
+++ b/packages/vlossom/src/components/vs-table/composables/index.ts
@@ -0,0 +1,8 @@
+export * from './table-expand-composable';
+export * from './table-filter-composable';
+export * from './table-pagination-composable';
+export * from './table-params-composable';
+export * from './table-search-composable';
+export * from './table-select-composable';
+export * from './table-sort-composable';
+export * from './table-sortable-header-composable';
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableExpand.ts b/packages/vlossom/src/components/vs-table/composables/table-expand-composable.ts
similarity index 100%
rename from packages/vlossom/src/components/vs-table/composables/useTableExpand.ts
rename to packages/vlossom/src/components/vs-table/composables/table-expand-composable.ts
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableFilter.ts b/packages/vlossom/src/components/vs-table/composables/table-filter-composable.ts
similarity index 92%
rename from packages/vlossom/src/components/vs-table/composables/useTableFilter.ts
rename to packages/vlossom/src/components/vs-table/composables/table-filter-composable.ts
index 3d862f1a5..34d6096b5 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTableFilter.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-filter-composable.ts
@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { TableItem, TableFilter } from './../types';
+import { TableItem, TableFilter } from '../types';
 
 export function useTableFilter() {
     function getFilteredTableItems(tableItems: TableItem[], filter: Ref<TableFilter>): TableItem[] {
diff --git a/packages/vlossom/src/components/vs-table/composables/useTablePagination.ts b/packages/vlossom/src/components/vs-table/composables/table-pagination-composable.ts
similarity index 93%
rename from packages/vlossom/src/components/vs-table/composables/useTablePagination.ts
rename to packages/vlossom/src/components/vs-table/composables/table-pagination-composable.ts
index 298efe00f..d0897cfcd 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTablePagination.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-pagination-composable.ts
@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { TableItem } from './../types';
+import { TableItem } from '../types';
 
 export function useTablePagination() {
     function getPagedTableItems(
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableParams.ts b/packages/vlossom/src/components/vs-table/composables/table-params-composable.ts
similarity index 93%
rename from packages/vlossom/src/components/vs-table/composables/useTableParams.ts
rename to packages/vlossom/src/components/vs-table/composables/table-params-composable.ts
index 31f766864..4efedeed1 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTableParams.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-params-composable.ts
@@ -1,6 +1,6 @@
 import { ComputedRef, Ref, computed, watch } from 'vue';
 import { utils } from '@/utils';
-import { SortType, TableParams } from './../types';
+import { SortType, TableParams } from '../types';
 
 export function useTableParams(
     page: Ref<number>,
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableSearch.ts b/packages/vlossom/src/components/vs-table/composables/table-search-composable.ts
similarity index 61%
rename from packages/vlossom/src/components/vs-table/composables/useTableSearch.ts
rename to packages/vlossom/src/components/vs-table/composables/table-search-composable.ts
index ec5a202fd..244d7b42d 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTableSearch.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-search-composable.ts
@@ -11,18 +11,27 @@ export function useTableSearch(headers: Ref<TableHeader[]>, searchableKeys: Ref<
     });
 
     function getSearchedTableItems(tableItems: TableItem[], keyword: Ref<string>): TableItem[] {
-        if (keyword.value.trim() === '') {
+        if (!keyword.value || keyword.value.trim() === '') {
             return tableItems;
         }
         const lowercaseKeyword = keyword.value.trim().toLowerCase();
         return tableItems.filter(({ data }) => {
-            const searchableData = utils.object.pick(data, searchTargetKeys.value);
-            const target = Object.values(searchableData).join(' ').toLowerCase();
+            const searchableData = utils.object.pickWithPath(data, searchTargetKeys.value);
+            const target = Object.values(searchableData)
+                .map((v: any) => {
+                    if (utils.object.isPlainObject(v) || utils.object.isArray(v)) {
+                        return JSON.stringify(v);
+                    }
+                    return v;
+                })
+                .join(' ')
+                .toLowerCase();
             return target.includes(lowercaseKeyword);
         });
     }
 
     return {
+        searchTargetKeys,
         getSearchedTableItems,
     };
 }
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableSelect.ts b/packages/vlossom/src/components/vs-table/composables/table-select-composable.ts
similarity index 98%
rename from packages/vlossom/src/components/vs-table/composables/useTableSelect.ts
rename to packages/vlossom/src/components/vs-table/composables/table-select-composable.ts
index 21a8e023a..3e925c5f7 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTableSelect.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-select-composable.ts
@@ -1,5 +1,5 @@
 import { Ref, WritableComputedRef, computed, ComputedRef, ref, watch } from 'vue';
-import type { TableItem, TableRow } from './../types';
+import type { TableItem, TableRow } from '../types';
 import { utils } from '@/utils';
 
 export function useTableSelect(
diff --git a/packages/vlossom/src/components/vs-table/composables/useTableSort.ts b/packages/vlossom/src/components/vs-table/composables/table-sort-composable.ts
similarity index 94%
rename from packages/vlossom/src/components/vs-table/composables/useTableSort.ts
rename to packages/vlossom/src/components/vs-table/composables/table-sort-composable.ts
index 1ec53b6b6..946e307a3 100644
--- a/packages/vlossom/src/components/vs-table/composables/useTableSort.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-sort-composable.ts
@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { TableItem, SortType } from './../types';
+import { TableItem, SortType } from '../types';
 
 export function useTableSort() {
     function getSortedTableItems(items: TableItem[], sortTypes: Ref<{ [key: string]: SortType }>) {
diff --git a/packages/vlossom/src/components/vs-table/composables/useSortableHeader.ts b/packages/vlossom/src/components/vs-table/composables/table-sortable-header-composable.ts
similarity index 96%
rename from packages/vlossom/src/components/vs-table/composables/useSortableHeader.ts
rename to packages/vlossom/src/components/vs-table/composables/table-sortable-header-composable.ts
index bdaec7069..58d42de9f 100644
--- a/packages/vlossom/src/components/vs-table/composables/useSortableHeader.ts
+++ b/packages/vlossom/src/components/vs-table/composables/table-sortable-header-composable.ts
@@ -1,5 +1,5 @@
 import { Ref, ref, watch } from 'vue';
-import { SortType, TableHeader } from './../types';
+import { SortType, TableHeader } from '../types';
 
 export function useSortableHeader(headers: Ref<TableHeader[]>, ctx: any) {
     const innerSortTypes: Ref<{ [key: string]: SortType }> = ref({});
diff --git a/packages/vlossom/src/utils/__tests__/object.test.ts b/packages/vlossom/src/utils/__tests__/object.test.ts
index 7ab26b4a2..0a6e47c5d 100644
--- a/packages/vlossom/src/utils/__tests__/object.test.ts
+++ b/packages/vlossom/src/utils/__tests__/object.test.ts
@@ -77,4 +77,17 @@ describe('object util', () => {
             expect(result5).toBe(false);
         });
     });
+
+    describe('pickWithPath', () => {
+        it('path를 기준으로 pick 할 수 있다', () => {
+            // given
+            const object = { a: 1, b: 'hello', c: { d: true, e: { f: ['A', 'B'] } } };
+
+            // when
+            const result = objectUtil.pickWithPath(object, ['a', 'c.d', 'c.e.f']);
+
+            // then
+            expect(result).toEqual({ a: 1, 'c.d': true, 'c.e.f': ['A', 'B'] });
+        });
+    });
 });
diff --git a/packages/vlossom/src/utils/object.ts b/packages/vlossom/src/utils/object.ts
index fc6266717..873d93903 100644
--- a/packages/vlossom/src/utils/object.ts
+++ b/packages/vlossom/src/utils/object.ts
@@ -1,19 +1,25 @@
-import * as _ from 'radash';
+import { get, isEqual, isArray, unique, isObject, omit, pick } from 'radash';
 
 export const objectUtil = {
-    get: _.get,
-
-    isEqual: _.isEqual,
-
+    get,
+    isEqual,
+    isArray,
+    unique,
     isUniq(array: any[]): boolean {
-        return _.unique(array).length === array.length;
+        return unique(array).length === array.length;
     },
-
     isPlainObject(value: any): value is Record<string, any> {
-        return _.isObject(value);
+        return isObject(value);
+    },
+    omit,
+    pick,
+    pickWithPath(object: Record<string, any>, keys: string[]): Pick<string, any> {
+        return keys.reduce(
+            (acc, key) => {
+                acc[key] = this.get(object, key);
+                return acc;
+            },
+            {} as Record<string, any>,
+        );
     },
-
-    omit: _.omit,
-
-    pick: _.pick,
 };