diff --git a/CHANGELOG.md b/CHANGELOG.md
index 132a0a23bf5c..be2777365bd4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -42,6 +42,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - [Theme] Make `next` theme the default ([#4854](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4854))
 - [Discover] Update embeddable for saved searches ([#5081](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5081))
 - [Workspace] Add core workspace service module to enable the implementation of workspace features within OSD plugins ([#5092](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5092))
+- [Workspace] Optional workspaces params in repository ([#5162](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5162))
 
 ### 🐛 Bug Fixes
 
diff --git a/src/core/public/saved_objects/saved_objects_client.ts b/src/core/public/saved_objects/saved_objects_client.ts
index 6e5482614e40..d6b6b6b6d89c 100644
--- a/src/core/public/saved_objects/saved_objects_client.ts
+++ b/src/core/public/saved_objects/saved_objects_client.ts
@@ -345,6 +345,7 @@ export class SavedObjectsClient {
       filter: 'filter',
       namespaces: 'namespaces',
       preference: 'preference',
+      workspaces: 'workspaces',
     };
 
     const renamedQuery = renameKeys<SavedObjectsFindOptions, any>(renameMap, options);
diff --git a/src/core/server/saved_objects/export/get_sorted_objects_for_export.test.ts b/src/core/server/saved_objects/export/get_sorted_objects_for_export.test.ts
index cf7e1d8246a7..0fb602629c55 100644
--- a/src/core/server/saved_objects/export/get_sorted_objects_for_export.test.ts
+++ b/src/core/server/saved_objects/export/get_sorted_objects_for_export.test.ts
@@ -857,4 +857,17 @@ describe('getSortedObjectsForExport()', () => {
       `Can't specify both "search" and "objects" properties when exporting`
     );
   });
+
+  test('rejects when both types and objecys are passed in', () => {
+    const exportOpts = {
+      exportSizeLimit: 1,
+      savedObjectsClient,
+      objects: [{ type: 'index-pattern', id: '1' }],
+      types: ['foo'],
+    };
+
+    expect(exportSavedObjectsToStream(exportOpts)).rejects.toThrowErrorMatchingInlineSnapshot(
+      `Can't specify both "types" and "objects" properties when exporting`
+    );
+  });
 });
diff --git a/src/core/server/saved_objects/export/get_sorted_objects_for_export.ts b/src/core/server/saved_objects/export/get_sorted_objects_for_export.ts
index 7bf6e9f6ccdc..660f86846137 100644
--- a/src/core/server/saved_objects/export/get_sorted_objects_for_export.ts
+++ b/src/core/server/saved_objects/export/get_sorted_objects_for_export.ts
@@ -60,6 +60,8 @@ export interface SavedObjectsExportOptions {
   excludeExportDetails?: boolean;
   /** optional namespace to override the namespace used by the savedObjectsClient. */
   namespace?: string;
+  /** optional workspaces to override the workspaces used by the savedObjectsClient. */
+  workspaces?: string[];
 }
 
 /**
@@ -87,6 +89,7 @@ async function fetchObjectsToExport({
   exportSizeLimit,
   savedObjectsClient,
   namespace,
+  workspaces,
 }: {
   objects?: SavedObjectsExportOptions['objects'];
   types?: string[];
@@ -94,6 +97,7 @@ async function fetchObjectsToExport({
   exportSizeLimit: number;
   savedObjectsClient: SavedObjectsClientContract;
   namespace?: string;
+  workspaces?: string[];
 }) {
   if ((types?.length ?? 0) > 0 && (objects?.length ?? 0) > 0) {
     throw Boom.badRequest(`Can't specify both "types" and "objects" properties when exporting`);
@@ -105,7 +109,9 @@ async function fetchObjectsToExport({
     if (typeof search === 'string') {
       throw Boom.badRequest(`Can't specify both "search" and "objects" properties when exporting`);
     }
-    const bulkGetResult = await savedObjectsClient.bulkGet(objects, { namespace });
+    const bulkGetResult = await savedObjectsClient.bulkGet(objects, {
+      namespace,
+    });
     const erroredObjects = bulkGetResult.saved_objects.filter((obj) => !!obj.error);
     if (erroredObjects.length) {
       const err = Boom.badRequest();
@@ -121,6 +127,7 @@ async function fetchObjectsToExport({
       search,
       perPage: exportSizeLimit,
       namespaces: namespace ? [namespace] : undefined,
+      ...(workspaces ? { workspaces } : {}),
     });
     if (findResponse.total > exportSizeLimit) {
       throw Boom.badRequest(`Can't export more than ${exportSizeLimit} objects`);
@@ -153,6 +160,7 @@ export async function exportSavedObjectsToStream({
   includeReferencesDeep = false,
   excludeExportDetails = false,
   namespace,
+  workspaces,
 }: SavedObjectsExportOptions) {
   const rootObjects = await fetchObjectsToExport({
     types,
@@ -161,6 +169,7 @@ export async function exportSavedObjectsToStream({
     savedObjectsClient,
     exportSizeLimit,
     namespace,
+    workspaces,
   });
   let exportedObjects: Array<SavedObject<unknown>> = [];
   let missingReferences: SavedObjectsExportResultDetails['missingReferences'] = [];
diff --git a/src/core/server/saved_objects/import/check_conflicts.ts b/src/core/server/saved_objects/import/check_conflicts.ts
index 830f7f55d7c5..f36bcf3a8a92 100644
--- a/src/core/server/saved_objects/import/check_conflicts.ts
+++ b/src/core/server/saved_objects/import/check_conflicts.ts
@@ -44,6 +44,7 @@ interface CheckConflictsParams {
   ignoreRegularConflicts?: boolean;
   retries?: SavedObjectsImportRetry[];
   createNewCopies?: boolean;
+  workspaces?: string[];
 }
 
 const isUnresolvableConflict = (error: SavedObjectError) =>
@@ -56,6 +57,7 @@ export async function checkConflicts({
   ignoreRegularConflicts,
   retries = [],
   createNewCopies,
+  workspaces,
 }: CheckConflictsParams) {
   const filteredObjects: Array<SavedObject<{ title?: string }>> = [];
   const errors: SavedObjectsImportError[] = [];
@@ -77,6 +79,7 @@ export async function checkConflicts({
   });
   const checkConflictsResult = await savedObjectsClient.checkConflicts(objectsToCheck, {
     namespace,
+    workspaces,
   });
   const errorMap = checkConflictsResult.errors.reduce(
     (acc, { type, id, error }) => acc.set(`${type}:${id}`, error),
diff --git a/src/core/server/saved_objects/import/create_saved_objects.ts b/src/core/server/saved_objects/import/create_saved_objects.ts
index a3a1eebbd2ab..6982f21bbf37 100644
--- a/src/core/server/saved_objects/import/create_saved_objects.ts
+++ b/src/core/server/saved_objects/import/create_saved_objects.ts
@@ -39,6 +39,7 @@ interface CreateSavedObjectsParams<T> {
   importIdMap: Map<string, { id?: string; omitOriginId?: boolean }>;
   namespace?: string;
   overwrite?: boolean;
+  workspaces?: string[];
 }
 interface CreateSavedObjectsResult<T> {
   createdObjects: Array<CreatedObject<T>>;
@@ -56,6 +57,7 @@ export const createSavedObjects = async <T>({
   importIdMap,
   namespace,
   overwrite,
+  workspaces,
 }: CreateSavedObjectsParams<T>): Promise<CreateSavedObjectsResult<T>> => {
   // filter out any objects that resulted in errors
   const errorSet = accumulatedErrors.reduce(
@@ -103,6 +105,7 @@ export const createSavedObjects = async <T>({
     const bulkCreateResponse = await savedObjectsClient.bulkCreate(objectsToCreate, {
       namespace,
       overwrite,
+      workspaces,
     });
     expectedResults = bulkCreateResponse.saved_objects;
   }
diff --git a/src/core/server/saved_objects/import/import_saved_objects.test.ts b/src/core/server/saved_objects/import/import_saved_objects.test.ts
index de8fb34dfbed..d0e4eda7ab3c 100644
--- a/src/core/server/saved_objects/import/import_saved_objects.test.ts
+++ b/src/core/server/saved_objects/import/import_saved_objects.test.ts
@@ -165,7 +165,9 @@ describe('#importSavedObjectsFromStream', () => {
       expect(validateReferences).toHaveBeenCalledWith(
         collectedObjects,
         savedObjectsClient,
-        namespace
+        namespace,
+        undefined,
+        undefined
       );
     });
 
@@ -268,6 +270,52 @@ describe('#importSavedObjectsFromStream', () => {
         };
         expect(createSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
       });
+
+      test('creates saved objects when workspaces param is provided', async () => {
+        const options = setupOptions();
+        options.workspaces = ['foo'];
+        const collectedObjects = [createObject()];
+        const filteredObjects = [createObject()];
+        const errors = [createError(), createError(), createError(), createError()];
+        getMockFn(collectSavedObjects).mockResolvedValue({
+          errors: [errors[0]],
+          collectedObjects,
+          importIdMap: new Map([
+            ['foo', {}],
+            ['bar', {}],
+            ['baz', {}],
+          ]),
+        });
+        getMockFn(validateReferences).mockResolvedValue([errors[1]]);
+        getMockFn(checkConflicts).mockResolvedValue({
+          errors: [errors[2]],
+          filteredObjects,
+          importIdMap: new Map([['bar', { id: 'newId1' }]]),
+          pendingOverwrites: new Set(),
+        });
+        getMockFn(checkOriginConflicts).mockResolvedValue({
+          errors: [errors[3]],
+          importIdMap: new Map([['baz', { id: 'newId2' }]]),
+          pendingOverwrites: new Set(),
+        });
+
+        await importSavedObjectsFromStream(options);
+        const importIdMap = new Map([
+          ['foo', {}],
+          ['bar', { id: 'newId1' }],
+          ['baz', { id: 'newId2' }],
+        ]);
+        const createSavedObjectsParams = {
+          objects: collectedObjects,
+          accumulatedErrors: errors,
+          savedObjectsClient,
+          importIdMap,
+          overwrite,
+          namespace,
+          workspaces: options.workspaces,
+        };
+        expect(createSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
+      });
     });
 
     describe('with createNewCopies enabled', () => {
diff --git a/src/core/server/saved_objects/import/import_saved_objects.ts b/src/core/server/saved_objects/import/import_saved_objects.ts
index cd250fc5f65f..b283f10c2364 100644
--- a/src/core/server/saved_objects/import/import_saved_objects.ts
+++ b/src/core/server/saved_objects/import/import_saved_objects.ts
@@ -54,6 +54,7 @@ export async function importSavedObjectsFromStream({
   savedObjectsClient,
   typeRegistry,
   namespace,
+  workspaces,
 }: SavedObjectsImportOptions): Promise<SavedObjectsImportResponse> {
   let errorAccumulator: SavedObjectsImportError[] = [];
   const supportedTypes = typeRegistry.getImportableAndExportableTypes().map((type) => type.name);
@@ -73,7 +74,9 @@ export async function importSavedObjectsFromStream({
   const validateReferencesResult = await validateReferences(
     collectSavedObjectsResult.collectedObjects,
     savedObjectsClient,
-    namespace
+    namespace,
+    undefined,
+    workspaces
   );
   errorAccumulator = [...errorAccumulator, ...validateReferencesResult];
 
@@ -81,11 +84,13 @@ export async function importSavedObjectsFromStream({
     importIdMap = regenerateIds(collectSavedObjectsResult.collectedObjects);
   } else {
     // Check single-namespace objects for conflicts in this namespace, and check multi-namespace objects for conflicts across all namespaces
+    // Check for conflicts across all workspaces
     const checkConflictsParams = {
       objects: collectSavedObjectsResult.collectedObjects,
       savedObjectsClient,
       namespace,
       ignoreRegularConflicts: overwrite,
+      workspaces,
     };
     const checkConflictsResult = await checkConflicts(checkConflictsParams);
     errorAccumulator = [...errorAccumulator, ...checkConflictsResult.errors];
@@ -118,6 +123,7 @@ export async function importSavedObjectsFromStream({
     importIdMap,
     overwrite,
     namespace,
+    ...(workspaces ? { workspaces } : {}),
   };
   const createSavedObjectsResult = await createSavedObjects(createSavedObjectsParams);
   errorAccumulator = [...errorAccumulator, ...createSavedObjectsResult.errors];
diff --git a/src/core/server/saved_objects/import/resolve_import_errors.ts b/src/core/server/saved_objects/import/resolve_import_errors.ts
index 162410c4ce9b..207410136645 100644
--- a/src/core/server/saved_objects/import/resolve_import_errors.ts
+++ b/src/core/server/saved_objects/import/resolve_import_errors.ts
@@ -59,6 +59,7 @@ export async function resolveSavedObjectsImportErrors({
   typeRegistry,
   namespace,
   createNewCopies,
+  workspaces,
 }: SavedObjectsResolveImportErrorsOptions): Promise<SavedObjectsImportResponse> {
   // throw a BadRequest error if we see invalid retries
   validateRetries(retries);
@@ -157,6 +158,7 @@ export async function resolveSavedObjectsImportErrors({
       importIdMap,
       namespace,
       overwrite,
+      workspaces,
     };
     const { createdObjects, errors: bulkCreateErrors } = await createSavedObjects(
       createSavedObjectsParams
diff --git a/src/core/server/saved_objects/import/types.ts b/src/core/server/saved_objects/import/types.ts
index 88beacb9d2fd..924d1b18895a 100644
--- a/src/core/server/saved_objects/import/types.ts
+++ b/src/core/server/saved_objects/import/types.ts
@@ -187,6 +187,8 @@ export interface SavedObjectsImportOptions {
   namespace?: string;
   /** If true, will create new copies of import objects, each with a random `id` and undefined `originId`. */
   createNewCopies: boolean;
+  /** if specified, will import in given workspaces, else will import as global object */
+  workspaces?: string[];
 }
 
 /**
@@ -208,6 +210,8 @@ export interface SavedObjectsResolveImportErrorsOptions {
   namespace?: string;
   /** If true, will create new copies of import objects, each with a random `id` and undefined `originId`. */
   createNewCopies: boolean;
+  /** if specified, will import in given workspaces, else will import as global object */
+  workspaces?: string[];
 }
 
 export type CreatedObject<T> = SavedObject<T> & { destinationId?: string };
diff --git a/src/core/server/saved_objects/import/validate_references.test.ts b/src/core/server/saved_objects/import/validate_references.test.ts
index df9a4e216bbb..809b75c9320c 100644
--- a/src/core/server/saved_objects/import/validate_references.test.ts
+++ b/src/core/server/saved_objects/import/validate_references.test.ts
@@ -601,4 +601,96 @@ describe('validateReferences()', () => {
       validateReferences(savedObjects, savedObjectsClient)
     ).rejects.toThrowErrorMatchingInlineSnapshot(`Bad Request`);
   });
+
+  test('returns errors when references have conflict on workspaces', async () => {
+    savedObjectsClient.bulkGet.mockResolvedValue({
+      saved_objects: [
+        {
+          type: 'index-pattern',
+          id: '3',
+          attributes: {},
+          references: [],
+          workspaces: ['foo'],
+        },
+        {
+          type: 'index-pattern',
+          id: '5',
+          attributes: {},
+          references: [],
+          workspaces: ['bar'],
+        },
+      ],
+    });
+    const savedObjects = [
+      {
+        id: '5',
+        type: 'index-pattern',
+        attributes: {
+          title: 'My Visualization 2',
+        },
+        references: [
+          {
+            name: 'ref_0',
+            type: 'index-pattern',
+            id: '3',
+          },
+        ],
+      },
+    ];
+    const result = await validateReferences(
+      savedObjects,
+      savedObjectsClient,
+      undefined,
+      undefined,
+      ['bar']
+    );
+    expect(result).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          error: Object {
+            references: Array [
+              Object {
+                id: 3,
+                type: index-pattern,
+              },
+            ],
+            type: missing_references,
+          },
+          id: 5,
+          meta: Object {
+            title: My Visualization 2,
+          },
+          title: My Visualization 2,
+          type: index-pattern,
+        },
+      ]
+    `);
+    expect(savedObjectsClient.bulkGet).toMatchInlineSnapshot(`
+      [MockFunction] {
+        "calls": Array [
+          Array [
+            Array [
+              Object {
+                fields: Array [
+                  id,
+                  workspaces,
+                ],
+                id: 3,
+                type: index-pattern,
+              },
+            ],
+            Object {
+              namespace: undefined,
+            },
+          ],
+        ],
+        "results": Array [
+          Object {
+            type: return,
+            value: Promise {},
+          },
+        ],
+      }
+    `);
+  });
 });
diff --git a/src/core/server/saved_objects/import/validate_references.ts b/src/core/server/saved_objects/import/validate_references.ts
index fb75eb837443..1f9b4460b2f8 100644
--- a/src/core/server/saved_objects/import/validate_references.ts
+++ b/src/core/server/saved_objects/import/validate_references.ts
@@ -31,6 +31,7 @@
 import Boom from '@hapi/boom';
 import { SavedObject, SavedObjectsClientContract } from '../types';
 import { SavedObjectsImportError, SavedObjectsImportRetry } from './types';
+import { SavedObjectsUtils } from '../service';
 
 const REF_TYPES_TO_VLIDATE = ['index-pattern', 'search'];
 
@@ -48,7 +49,8 @@ export async function getNonExistingReferenceAsKeys(
   savedObjects: SavedObject[],
   savedObjectsClient: SavedObjectsClientContract,
   namespace?: string,
-  retries?: SavedObjectsImportRetry[]
+  retries?: SavedObjectsImportRetry[],
+  workspaces?: string[]
 ) {
   const objectsToSkip = getObjectsToSkip(retries);
   const collector = new Map();
@@ -72,8 +74,16 @@ export async function getNonExistingReferenceAsKeys(
     return [];
   }
 
+  const fields = ['id'];
+  if (workspaces?.length) {
+    fields.push('workspaces');
+  }
+
   // Fetch references to see if they exist
-  const bulkGetOpts = Array.from(collector.values()).map((obj) => ({ ...obj, fields: ['id'] }));
+  const bulkGetOpts = Array.from(collector.values()).map((obj) => ({
+    ...obj,
+    fields,
+  }));
   const bulkGetResponse = await savedObjectsClient.bulkGet(bulkGetOpts, { namespace });
 
   // Error handling
@@ -93,6 +103,20 @@ export async function getNonExistingReferenceAsKeys(
     if (savedObject.error) {
       continue;
     }
+    /**
+     * If original workspaces have conflict with target workspace
+     * make it as NonExistingReference
+     */
+    if (workspaces) {
+      if (
+        SavedObjectsUtils.filterWorkspacesAccordingToSourceWorkspaces(
+          workspaces,
+          savedObject.workspaces
+        ).length
+      ) {
+        continue;
+      }
+    }
     collector.delete(`${savedObject.type}:${savedObject.id}`);
   }
 
@@ -103,7 +127,8 @@ export async function validateReferences(
   savedObjects: Array<SavedObject<{ title?: string }>>,
   savedObjectsClient: SavedObjectsClientContract,
   namespace?: string,
-  retries?: SavedObjectsImportRetry[]
+  retries?: SavedObjectsImportRetry[],
+  workspaces?: string[]
 ) {
   const objectsToSkip = getObjectsToSkip(retries);
   const errorMap: { [key: string]: SavedObjectsImportError } = {};
@@ -111,7 +136,8 @@ export async function validateReferences(
     savedObjects,
     savedObjectsClient,
     namespace,
-    retries
+    retries,
+    workspaces
   );
 
   // Filter out objects with missing references, add to error object
diff --git a/src/core/server/saved_objects/migrations/core/__snapshots__/build_active_mappings.test.ts.snap b/src/core/server/saved_objects/migrations/core/__snapshots__/build_active_mappings.test.ts.snap
index f8ef47cae894..254bdbb4b2c6 100644
--- a/src/core/server/saved_objects/migrations/core/__snapshots__/build_active_mappings.test.ts.snap
+++ b/src/core/server/saved_objects/migrations/core/__snapshots__/build_active_mappings.test.ts.snap
@@ -13,6 +13,7 @@ Object {
       "references": "7997cf5a56cc02bdc9c93361bde732b0",
       "type": "2f4316de49999235636386fe51dc06c1",
       "updated_at": "00da57df13e94e9d98437d13ace4bfe0",
+      "workspaces": "2f4316de49999235636386fe51dc06c1",
     },
   },
   "dynamic": "strict",
@@ -56,6 +57,9 @@ Object {
     "updated_at": Object {
       "type": "date",
     },
+    "workspaces": Object {
+      "type": "keyword",
+    },
   },
 }
 `;
@@ -74,6 +78,7 @@ Object {
       "thirdType": "510f1f0adb69830cf8a1c5ce2923ed82",
       "type": "2f4316de49999235636386fe51dc06c1",
       "updated_at": "00da57df13e94e9d98437d13ace4bfe0",
+      "workspaces": "2f4316de49999235636386fe51dc06c1",
     },
   },
   "dynamic": "strict",
@@ -134,6 +139,9 @@ Object {
     "updated_at": Object {
       "type": "date",
     },
+    "workspaces": Object {
+      "type": "keyword",
+    },
   },
 }
 `;
diff --git a/src/core/server/saved_objects/migrations/core/build_active_mappings.ts b/src/core/server/saved_objects/migrations/core/build_active_mappings.ts
index bf377a13a42e..812cc1fd5eb1 100644
--- a/src/core/server/saved_objects/migrations/core/build_active_mappings.ts
+++ b/src/core/server/saved_objects/migrations/core/build_active_mappings.ts
@@ -175,6 +175,9 @@ function defaultMapping(): IndexMapping {
           },
         },
       },
+      workspaces: {
+        type: 'keyword',
+      },
     },
   };
 }
diff --git a/src/core/server/saved_objects/migrations/core/index_migrator.test.ts b/src/core/server/saved_objects/migrations/core/index_migrator.test.ts
index 4bacfda3bd5a..4b65da5250d6 100644
--- a/src/core/server/saved_objects/migrations/core/index_migrator.test.ts
+++ b/src/core/server/saved_objects/migrations/core/index_migrator.test.ts
@@ -82,6 +82,7 @@ describe('IndexMigrator', () => {
               references: '7997cf5a56cc02bdc9c93361bde732b0',
               type: '2f4316de49999235636386fe51dc06c1',
               updated_at: '00da57df13e94e9d98437d13ace4bfe0',
+              workspaces: '2f4316de49999235636386fe51dc06c1',
             },
           },
           properties: {
@@ -92,6 +93,9 @@ describe('IndexMigrator', () => {
             originId: { type: 'keyword' },
             type: { type: 'keyword' },
             updated_at: { type: 'date' },
+            workspaces: {
+              type: 'keyword',
+            },
             references: {
               type: 'nested',
               properties: {
@@ -199,6 +203,7 @@ describe('IndexMigrator', () => {
               references: '7997cf5a56cc02bdc9c93361bde732b0',
               type: '2f4316de49999235636386fe51dc06c1',
               updated_at: '00da57df13e94e9d98437d13ace4bfe0',
+              workspaces: '2f4316de49999235636386fe51dc06c1',
             },
           },
           properties: {
@@ -210,6 +215,9 @@ describe('IndexMigrator', () => {
             originId: { type: 'keyword' },
             type: { type: 'keyword' },
             updated_at: { type: 'date' },
+            workspaces: {
+              type: 'keyword',
+            },
             references: {
               type: 'nested',
               properties: {
@@ -260,6 +268,7 @@ describe('IndexMigrator', () => {
               references: '7997cf5a56cc02bdc9c93361bde732b0',
               type: '2f4316de49999235636386fe51dc06c1',
               updated_at: '00da57df13e94e9d98437d13ace4bfe0',
+              workspaces: '2f4316de49999235636386fe51dc06c1',
             },
           },
           properties: {
@@ -271,6 +280,9 @@ describe('IndexMigrator', () => {
             originId: { type: 'keyword' },
             type: { type: 'keyword' },
             updated_at: { type: 'date' },
+            workspaces: {
+              type: 'keyword',
+            },
             references: {
               type: 'nested',
               properties: {
diff --git a/src/core/server/saved_objects/migrations/opensearch_dashboards/__snapshots__/opensearch_dashboards_migrator.test.ts.snap b/src/core/server/saved_objects/migrations/opensearch_dashboards/__snapshots__/opensearch_dashboards_migrator.test.ts.snap
index baebb7848798..811d5f3594bf 100644
--- a/src/core/server/saved_objects/migrations/opensearch_dashboards/__snapshots__/opensearch_dashboards_migrator.test.ts.snap
+++ b/src/core/server/saved_objects/migrations/opensearch_dashboards/__snapshots__/opensearch_dashboards_migrator.test.ts.snap
@@ -13,6 +13,7 @@ Object {
       "references": "7997cf5a56cc02bdc9c93361bde732b0",
       "type": "2f4316de49999235636386fe51dc06c1",
       "updated_at": "00da57df13e94e9d98437d13ace4bfe0",
+      "workspaces": "2f4316de49999235636386fe51dc06c1",
     },
   },
   "dynamic": "strict",
@@ -64,6 +65,9 @@ Object {
     "updated_at": Object {
       "type": "date",
     },
+    "workspaces": Object {
+      "type": "keyword",
+    },
   },
 }
 `;
diff --git a/src/core/server/saved_objects/routes/bulk_create.ts b/src/core/server/saved_objects/routes/bulk_create.ts
index 5c2844d64813..36fd4bda5bff 100644
--- a/src/core/server/saved_objects/routes/bulk_create.ts
+++ b/src/core/server/saved_objects/routes/bulk_create.ts
@@ -38,6 +38,9 @@ export const registerBulkCreateRoute = (router: IRouter) => {
       validate: {
         query: schema.object({
           overwrite: schema.boolean({ defaultValue: false }),
+          workspaces: schema.maybe(
+            schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+          ),
         }),
         body: schema.arrayOf(
           schema.object({
@@ -62,7 +65,14 @@ export const registerBulkCreateRoute = (router: IRouter) => {
     },
     router.handleLegacyErrors(async (context, req, res) => {
       const { overwrite } = req.query;
-      const result = await context.core.savedObjects.client.bulkCreate(req.body, { overwrite });
+      let workspaces = req.query.workspaces;
+      if (typeof workspaces === 'string') {
+        workspaces = [workspaces];
+      }
+      const result = await context.core.savedObjects.client.bulkCreate(req.body, {
+        overwrite,
+        workspaces,
+      });
       return res.ok({ body: result });
     })
   );
diff --git a/src/core/server/saved_objects/routes/create.ts b/src/core/server/saved_objects/routes/create.ts
index c8c330ba7774..4d22bd244a03 100644
--- a/src/core/server/saved_objects/routes/create.ts
+++ b/src/core/server/saved_objects/routes/create.ts
@@ -56,15 +56,23 @@ export const registerCreateRoute = (router: IRouter) => {
             )
           ),
           initialNamespaces: schema.maybe(schema.arrayOf(schema.string(), { minSize: 1 })),
+          workspaces: schema.maybe(schema.arrayOf(schema.string(), { minSize: 1 })),
         }),
       },
     },
     router.handleLegacyErrors(async (context, req, res) => {
       const { type, id } = req.params;
       const { overwrite } = req.query;
-      const { attributes, migrationVersion, references, initialNamespaces } = req.body;
+      const { attributes, migrationVersion, references, initialNamespaces, workspaces } = req.body;
 
-      const options = { id, overwrite, migrationVersion, references, initialNamespaces };
+      const options = {
+        id,
+        overwrite,
+        migrationVersion,
+        references,
+        initialNamespaces,
+        workspaces,
+      };
       const result = await context.core.savedObjects.client.create(type, attributes, options);
       return res.ok({ body: result });
     })
diff --git a/src/core/server/saved_objects/routes/export.ts b/src/core/server/saved_objects/routes/export.ts
index 2c808b731b4e..9325b632e40f 100644
--- a/src/core/server/saved_objects/routes/export.ts
+++ b/src/core/server/saved_objects/routes/export.ts
@@ -57,12 +57,20 @@ export const registerExportRoute = (router: IRouter, config: SavedObjectConfig)
           search: schema.maybe(schema.string()),
           includeReferencesDeep: schema.boolean({ defaultValue: false }),
           excludeExportDetails: schema.boolean({ defaultValue: false }),
+          workspaces: schema.maybe(schema.arrayOf(schema.string())),
         }),
       },
     },
     router.handleLegacyErrors(async (context, req, res) => {
       const savedObjectsClient = context.core.savedObjects.client;
-      const { type, objects, search, excludeExportDetails, includeReferencesDeep } = req.body;
+      const {
+        type,
+        objects,
+        search,
+        excludeExportDetails,
+        includeReferencesDeep,
+        workspaces,
+      } = req.body;
       const types = typeof type === 'string' ? [type] : type;
 
       // need to access the registry for type validation, can't use the schema for this
@@ -98,6 +106,7 @@ export const registerExportRoute = (router: IRouter, config: SavedObjectConfig)
         exportSizeLimit: maxImportExportSize,
         includeReferencesDeep,
         excludeExportDetails,
+        workspaces,
       });
 
       const docsToExport: string[] = await createPromiseFromStreams([
diff --git a/src/core/server/saved_objects/routes/find.ts b/src/core/server/saved_objects/routes/find.ts
index dbc9bf9e3a0d..6cfb2d780036 100644
--- a/src/core/server/saved_objects/routes/find.ts
+++ b/src/core/server/saved_objects/routes/find.ts
@@ -59,6 +59,9 @@ export const registerFindRoute = (router: IRouter) => {
           namespaces: schema.maybe(
             schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
           ),
+          workspaces: schema.maybe(
+            schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+          ),
         }),
       },
     },
@@ -67,6 +70,10 @@ export const registerFindRoute = (router: IRouter) => {
 
       const namespaces =
         typeof req.query.namespaces === 'string' ? [req.query.namespaces] : req.query.namespaces;
+      let workspaces = req.query.workspaces;
+      if (typeof workspaces === 'string') {
+        workspaces = [workspaces];
+      }
 
       const result = await context.core.savedObjects.client.find({
         perPage: query.per_page,
@@ -81,6 +88,7 @@ export const registerFindRoute = (router: IRouter) => {
         fields: typeof query.fields === 'string' ? [query.fields] : query.fields,
         filter: query.filter,
         namespaces,
+        workspaces,
       });
 
       return res.ok({ body: result });
diff --git a/src/core/server/saved_objects/routes/import.ts b/src/core/server/saved_objects/routes/import.ts
index b157feb0860e..2d221d2d47bc 100644
--- a/src/core/server/saved_objects/routes/import.ts
+++ b/src/core/server/saved_objects/routes/import.ts
@@ -60,6 +60,9 @@ export const registerImportRoute = (router: IRouter, config: SavedObjectConfig)
           {
             overwrite: schema.boolean({ defaultValue: false }),
             createNewCopies: schema.boolean({ defaultValue: false }),
+            workspaces: schema.maybe(
+              schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+            ),
           },
           {
             validate: (object) => {
@@ -91,6 +94,11 @@ export const registerImportRoute = (router: IRouter, config: SavedObjectConfig)
         });
       }
 
+      let workspaces = req.query.workspaces;
+      if (typeof workspaces === 'string') {
+        workspaces = [workspaces];
+      }
+
       const result = await importSavedObjectsFromStream({
         savedObjectsClient: context.core.savedObjects.client,
         typeRegistry: context.core.savedObjects.typeRegistry,
@@ -98,6 +106,7 @@ export const registerImportRoute = (router: IRouter, config: SavedObjectConfig)
         objectLimit: maxImportExportSize,
         overwrite,
         createNewCopies,
+        workspaces,
       });
 
       return res.ok({ body: result });
diff --git a/src/core/server/saved_objects/routes/integration_tests/find.test.ts b/src/core/server/saved_objects/routes/integration_tests/find.test.ts
index fc21eefed434..b21425386400 100644
--- a/src/core/server/saved_objects/routes/integration_tests/find.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/find.test.ts
@@ -288,4 +288,38 @@ describe('GET /api/saved_objects/_find', () => {
       defaultSearchOperator: 'OR',
     });
   });
+
+  it('accepts the query parameter workspaces as a string', async () => {
+    await supertest(httpSetup.server.listener)
+      .get('/api/saved_objects/_find?type=index-pattern&workspaces=foo')
+      .expect(200);
+
+    expect(savedObjectsClient.find).toHaveBeenCalledTimes(1);
+
+    const options = savedObjectsClient.find.mock.calls[0][0];
+    expect(options).toEqual({
+      defaultSearchOperator: 'OR',
+      perPage: 20,
+      page: 1,
+      type: ['index-pattern'],
+      workspaces: ['foo'],
+    });
+  });
+
+  it('accepts the query parameter workspaces as an array', async () => {
+    await supertest(httpSetup.server.listener)
+      .get('/api/saved_objects/_find?type=index-pattern&workspaces=default&workspaces=foo')
+      .expect(200);
+
+    expect(savedObjectsClient.find).toHaveBeenCalledTimes(1);
+
+    const options = savedObjectsClient.find.mock.calls[0][0];
+    expect(options).toEqual({
+      perPage: 20,
+      page: 1,
+      type: ['index-pattern'],
+      workspaces: ['default', 'foo'],
+      defaultSearchOperator: 'OR',
+    });
+  });
 });
diff --git a/src/core/server/saved_objects/routes/resolve_import_errors.ts b/src/core/server/saved_objects/routes/resolve_import_errors.ts
index 5e07125671f1..32d67b5ae8ab 100644
--- a/src/core/server/saved_objects/routes/resolve_import_errors.ts
+++ b/src/core/server/saved_objects/routes/resolve_import_errors.ts
@@ -58,6 +58,9 @@ export const registerResolveImportErrorsRoute = (router: IRouter, config: SavedO
       validate: {
         query: schema.object({
           createNewCopies: schema.boolean({ defaultValue: false }),
+          workspaces: schema.maybe(
+            schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+          ),
         }),
         body: schema.object({
           file: schema.stream(),
@@ -98,6 +101,11 @@ export const registerResolveImportErrorsRoute = (router: IRouter, config: SavedO
         });
       }
 
+      let workspaces = req.query.workspaces;
+      if (typeof workspaces === 'string') {
+        workspaces = [workspaces];
+      }
+
       const result = await resolveSavedObjectsImportErrors({
         typeRegistry: context.core.savedObjects.typeRegistry,
         savedObjectsClient: context.core.savedObjects.client,
@@ -105,6 +113,7 @@ export const registerResolveImportErrorsRoute = (router: IRouter, config: SavedO
         retries: req.body.retries,
         objectLimit: maxImportExportSize,
         createNewCopies: req.query.createNewCopies,
+        workspaces,
       });
 
       return res.ok({ body: result });
diff --git a/src/core/server/saved_objects/serialization/serializer.ts b/src/core/server/saved_objects/serialization/serializer.ts
index ff840a1fac60..5c3e22ac646a 100644
--- a/src/core/server/saved_objects/serialization/serializer.ts
+++ b/src/core/server/saved_objects/serialization/serializer.ts
@@ -73,7 +73,7 @@ export class SavedObjectsSerializer {
    */
   public rawToSavedObject(doc: SavedObjectsRawDoc): SavedObjectSanitizedDoc {
     const { _id, _source, _seq_no, _primary_term } = doc;
-    const { type, namespace, namespaces, originId } = _source;
+    const { type, namespace, namespaces, originId, workspaces } = _source;
 
     const version =
       _seq_no != null || _primary_term != null
@@ -91,6 +91,7 @@ export class SavedObjectsSerializer {
       ...(_source.migrationVersion && { migrationVersion: _source.migrationVersion }),
       ...(_source.updated_at && { updated_at: _source.updated_at }),
       ...(version && { version }),
+      ...(workspaces && { workspaces }),
     };
   }
 
@@ -112,6 +113,7 @@ export class SavedObjectsSerializer {
       updated_at,
       version,
       references,
+      workspaces,
     } = savedObj;
     const source = {
       [type]: attributes,
@@ -122,6 +124,7 @@ export class SavedObjectsSerializer {
       ...(originId && { originId }),
       ...(migrationVersion && { migrationVersion }),
       ...(updated_at && { updated_at }),
+      ...(workspaces && { workspaces }),
     };
 
     return {
diff --git a/src/core/server/saved_objects/serialization/types.ts b/src/core/server/saved_objects/serialization/types.ts
index d10ec75cdf41..473a63cf65f4 100644
--- a/src/core/server/saved_objects/serialization/types.ts
+++ b/src/core/server/saved_objects/serialization/types.ts
@@ -52,6 +52,7 @@ export interface SavedObjectsRawDocSource {
   updated_at?: string;
   references?: SavedObjectReference[];
   originId?: string;
+  workspaces?: string[];
 
   [typeMapping: string]: any;
 }
@@ -69,6 +70,7 @@ interface SavedObjectDoc<T = unknown> {
   version?: string;
   updated_at?: string;
   originId?: string;
+  workspaces?: string[];
 }
 
 interface Referencable {
diff --git a/src/core/server/saved_objects/service/lib/integration_tests/repository.test.ts b/src/core/server/saved_objects/service/lib/integration_tests/repository.test.ts
new file mode 100644
index 000000000000..b601de985dc0
--- /dev/null
+++ b/src/core/server/saved_objects/service/lib/integration_tests/repository.test.ts
@@ -0,0 +1,310 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SavedObject } from 'src/core/types';
+import { isEqual } from 'lodash';
+import * as osdTestServer from '../../../../../test_helpers/osd_server';
+import { Readable } from 'stream';
+
+const dashboard: Omit<SavedObject, 'id'> = {
+  type: 'dashboard',
+  attributes: {},
+  references: [],
+};
+
+describe('repository integration test', () => {
+  let root: ReturnType<typeof osdTestServer.createRoot>;
+  let opensearchServer: osdTestServer.TestOpenSearchUtils;
+  beforeAll(async () => {
+    const { startOpenSearch, startOpenSearchDashboards } = osdTestServer.createTestServers({
+      adjustTimeout: (t: number) => jest.setTimeout(t),
+    });
+    opensearchServer = await startOpenSearch();
+    const startOSDResp = await startOpenSearchDashboards();
+    root = startOSDResp.root;
+  }, 30000);
+  afterAll(async () => {
+    await root.shutdown();
+    await opensearchServer.stop();
+  });
+
+  const deleteItem = async (object: Pick<SavedObject, 'id' | 'type'>) => {
+    expect(
+      [200, 404].includes(
+        (await osdTestServer.request.delete(root, `/api/saved_objects/${object.type}/${object.id}`))
+          .statusCode
+      )
+    );
+  };
+
+  const getItem = async (object: Pick<SavedObject, 'id' | 'type'>) => {
+    return await osdTestServer.request
+      .get(root, `/api/saved_objects/${object.type}/${object.id}`)
+      .expect(200);
+  };
+
+  const clearFooAndBar = async () => {
+    await deleteItem({
+      type: dashboard.type,
+      id: 'foo',
+    });
+    await deleteItem({
+      type: dashboard.type,
+      id: 'bar',
+    });
+  };
+
+  describe('workspace related CRUD', () => {
+    it('create', async () => {
+      const createResult = await osdTestServer.request
+        .post(root, `/api/saved_objects/${dashboard.type}`)
+        .send({
+          attributes: dashboard.attributes,
+          workspaces: ['foo'],
+        })
+        .expect(200);
+
+      expect(createResult.body.workspaces).toEqual(['foo']);
+      await deleteItem({
+        type: dashboard.type,
+        id: createResult.body.id,
+      });
+    });
+
+    it('create-with-override', async () => {
+      const createResult = await osdTestServer.request
+        .post(root, `/api/saved_objects/${dashboard.type}`)
+        .send({
+          attributes: dashboard.attributes,
+          workspaces: ['foo'],
+        })
+        .expect(200);
+
+      await osdTestServer.request
+        .post(root, `/api/saved_objects/${dashboard.type}/${createResult.body.id}?overwrite=true`)
+        .send({
+          attributes: dashboard.attributes,
+          workspaces: ['bar'],
+        })
+        .expect(409);
+
+      await deleteItem({
+        type: dashboard.type,
+        id: createResult.body.id,
+      });
+    });
+
+    it('bulk create', async () => {
+      await clearFooAndBar();
+      const createResultFoo = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=foo`)
+        .send([
+          {
+            ...dashboard,
+            id: 'foo',
+          },
+        ])
+        .expect(200);
+
+      const createResultBar = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=bar`)
+        .send([
+          {
+            ...dashboard,
+            id: 'bar',
+          },
+        ])
+        .expect(200);
+
+      expect((createResultFoo.body.saved_objects as any[]).some((item) => item.error)).toEqual(
+        false
+      );
+      expect(
+        (createResultFoo.body.saved_objects as any[]).every((item) =>
+          isEqual(item.workspaces, ['foo'])
+        )
+      ).toEqual(true);
+      expect((createResultBar.body.saved_objects as any[]).some((item) => item.error)).toEqual(
+        false
+      );
+      expect(
+        (createResultBar.body.saved_objects as any[]).every((item) =>
+          isEqual(item.workspaces, ['bar'])
+        )
+      ).toEqual(true);
+      await Promise.all(
+        [...createResultFoo.body.saved_objects, ...createResultBar.body.saved_objects].map((item) =>
+          deleteItem({
+            type: item.type,
+            id: item.id,
+          })
+        )
+      );
+    });
+
+    it('bulk create with conflict', async () => {
+      await clearFooAndBar();
+      const createResultFoo = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=foo`)
+        .send([
+          {
+            ...dashboard,
+            id: 'foo',
+          },
+        ])
+        .expect(200);
+
+      const createResultBar = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=bar`)
+        .send([
+          {
+            ...dashboard,
+            id: 'bar',
+          },
+        ])
+        .expect(200);
+
+      /**
+       * overwrite with workspaces
+       */
+      const overwriteWithWorkspacesResult = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?overwrite=true&workspaces=foo`)
+        .send([
+          {
+            ...dashboard,
+            id: 'bar',
+          },
+          {
+            ...dashboard,
+            id: 'foo',
+            attributes: {
+              title: 'foo',
+            },
+          },
+        ])
+        .expect(200);
+
+      expect(overwriteWithWorkspacesResult.body.saved_objects[0].error.statusCode).toEqual(409);
+      expect(overwriteWithWorkspacesResult.body.saved_objects[1].attributes.title).toEqual('foo');
+      expect(overwriteWithWorkspacesResult.body.saved_objects[1].workspaces).toEqual(['foo']);
+
+      await Promise.all(
+        [...createResultFoo.body.saved_objects, ...createResultBar.body.saved_objects].map((item) =>
+          deleteItem({
+            type: item.type,
+            id: item.id,
+          })
+        )
+      );
+    });
+
+    it('checkConflicts when importing ndjson', async () => {
+      await clearFooAndBar();
+      const createResultFoo = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=foo`)
+        .send([
+          {
+            ...dashboard,
+            id: 'foo',
+          },
+        ])
+        .expect(200);
+
+      const createResultBar = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=bar`)
+        .send([
+          {
+            ...dashboard,
+            id: 'bar',
+          },
+        ])
+        .expect(200);
+
+      const getResultFoo = await getItem({
+        type: dashboard.type,
+        id: 'foo',
+      });
+      const getResultBar = await getItem({
+        type: dashboard.type,
+        id: 'bar',
+      });
+
+      const readableStream = new Readable();
+      readableStream.push(
+        `Content-Disposition: form-data; name="file"; filename="tmp.ndjson"\r\n\r\n`
+      );
+      readableStream.push(
+        [JSON.stringify(getResultFoo.body), JSON.stringify(getResultBar.body)].join('\n')
+      );
+      readableStream.push(null);
+
+      /**
+       * import with workspaces when conflicts
+       */
+      const importWithWorkspacesResult = await osdTestServer.request
+        .post(root, `/api/saved_objects/_import?workspaces=foo&overwrite=false`)
+        .attach(
+          'file',
+          Buffer.from(
+            [JSON.stringify(getResultFoo.body), JSON.stringify(getResultBar.body)].join('\n'),
+            'utf-8'
+          ),
+          'tmp.ndjson'
+        )
+        .expect(200);
+
+      expect(importWithWorkspacesResult.body.success).toEqual(false);
+      expect(importWithWorkspacesResult.body.errors.length).toEqual(1);
+      expect(importWithWorkspacesResult.body.errors[0].id).toEqual('foo');
+      expect(importWithWorkspacesResult.body.errors[0].error.type).toEqual('conflict');
+
+      await Promise.all(
+        [...createResultFoo.body.saved_objects, ...createResultBar.body.saved_objects].map((item) =>
+          deleteItem({
+            type: item.type,
+            id: item.id,
+          })
+        )
+      );
+    });
+
+    it('find by workspaces', async () => {
+      const createResultFoo = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=foo`)
+        .send([
+          {
+            ...dashboard,
+            id: 'foo',
+          },
+        ])
+        .expect(200);
+
+      const createResultBar = await osdTestServer.request
+        .post(root, `/api/saved_objects/_bulk_create?workspaces=bar`)
+        .send([
+          {
+            ...dashboard,
+            id: 'bar',
+          },
+        ])
+        .expect(200);
+
+      const findResult = await osdTestServer.request
+        .get(root, `/api/saved_objects/_find?workspaces=bar&type=${dashboard.type}`)
+        .expect(200);
+
+      expect(findResult.body.total).toEqual(1);
+      expect(findResult.body.saved_objects[0].workspaces).toEqual(['bar']);
+
+      await Promise.all(
+        [...createResultFoo.body.saved_objects, ...createResultBar.body.saved_objects].map((item) =>
+          deleteItem({
+            type: item.type,
+            id: item.id,
+          })
+        )
+      );
+    });
+  });
+});
diff --git a/src/core/server/saved_objects/service/lib/repository.test.js b/src/core/server/saved_objects/service/lib/repository.test.js
index fb5d366dd454..81ab1fb778dd 100644
--- a/src/core/server/saved_objects/service/lib/repository.test.js
+++ b/src/core/server/saved_objects/service/lib/repository.test.js
@@ -27,7 +27,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-
 import { SavedObjectsRepository } from './repository';
 import * as getSearchDslNS from './search_dsl/search_dsl';
 import { SavedObjectsErrorHelpers } from './errors';
@@ -54,6 +53,12 @@ const createGenericNotFoundError = (...args) =>
 const createUnsupportedTypeError = (...args) =>
   SavedObjectsErrorHelpers.createUnsupportedTypeError(...args).output.payload;
 
+const omitWorkspace = (object) => {
+  const newObject = JSON.parse(JSON.stringify(object));
+  delete newObject.workspaces;
+  return newObject;
+};
+
 describe('SavedObjectsRepository', () => {
   let client;
   let savedObjectsRepository;
@@ -168,7 +173,7 @@ describe('SavedObjectsRepository', () => {
   });
 
   const getMockGetResponse = (
-    { type, id, references, namespace: objectNamespace, originId },
+    { type, id, references, namespace: objectNamespace, originId, workspaces },
     namespace
   ) => {
     const namespaceId = objectNamespace === 'default' ? undefined : objectNamespace ?? namespace;
@@ -182,6 +187,7 @@ describe('SavedObjectsRepository', () => {
       _source: {
         ...(registry.isSingleNamespace(type) && { namespace: namespaceId }),
         ...(registry.isMultiNamespace(type) && { namespaces: [namespaceId ?? 'default'] }),
+        workspaces,
         ...(originId && { originId }),
         type,
         [type]: { title: 'Testing' },
@@ -444,6 +450,7 @@ describe('SavedObjectsRepository', () => {
       references: [{ name: 'ref_0', type: 'test', id: '2' }],
     };
     const namespace = 'foo-namespace';
+    const workspace = 'foo-workspace';
 
     const getMockBulkCreateResponse = (objects, namespace) => {
       return {
@@ -480,7 +487,9 @@ describe('SavedObjectsRepository', () => {
         opensearchClientMock.createSuccessTransportRequestPromise(response)
       );
       const result = await savedObjectsRepository.bulkCreate(objects, options);
-      expect(client.mget).toHaveBeenCalledTimes(multiNamespaceObjects?.length ? 1 : 0);
+      expect(client.mget).toHaveBeenCalledTimes(
+        multiNamespaceObjects?.length || options?.workspaces ? 1 : 0
+      );
       return result;
     };
 
@@ -683,6 +692,7 @@ describe('SavedObjectsRepository', () => {
             expect.anything()
           );
           client.bulk.mockClear();
+          client.mget.mockClear();
         };
         await test(undefined);
         await test(namespace);
@@ -730,6 +740,16 @@ describe('SavedObjectsRepository', () => {
         await bulkCreateSuccess(objects, { namespace });
         expectClientCallArgsAction(objects, { method: 'create', getId });
       });
+
+      it(`adds workspaces to request body for any types`, async () => {
+        await bulkCreateSuccess([obj1, obj2], { workspaces: [workspace] });
+        const expected = expect.objectContaining({ workspaces: [workspace] });
+        const body = [expect.any(Object), expected, expect.any(Object), expected];
+        expect(client.bulk).toHaveBeenCalledWith(
+          expect.objectContaining({ body }),
+          expect.anything()
+        );
+      });
     });
 
     describe('errors', () => {
@@ -877,6 +897,74 @@ describe('SavedObjectsRepository', () => {
         const expectedError = expectErrorResult(obj3, { message: JSON.stringify(opensearchError) });
         await bulkCreateError(obj3, opensearchError, expectedError);
       });
+
+      it(`returns error when there is a conflict with an existing saved object according to workspaces`, async () => {
+        const obj = { ...obj3, workspaces: ['foo'] };
+        const response1 = {
+          status: 200,
+          docs: [
+            {
+              found: true,
+              _id: `${obj1.type}:${obj1.id}`,
+              _source: {
+                type: obj1.type,
+                workspaces: ['bar'],
+              },
+            },
+            {
+              found: true,
+              _id: `${obj.type}:${obj.id}`,
+              _source: {
+                type: obj.type,
+                workspaces: obj.workspaces,
+              },
+            },
+            {
+              found: true,
+              _id: `${obj2.type}:${obj2.id}`,
+              _source: {
+                type: obj2.type,
+              },
+            },
+          ],
+        };
+        client.mget.mockResolvedValueOnce(
+          opensearchClientMock.createSuccessTransportRequestPromise(response1)
+        );
+        const response2 = getMockBulkCreateResponse([obj1, obj, obj2]);
+        client.bulk.mockResolvedValueOnce(
+          opensearchClientMock.createSuccessTransportRequestPromise(response2)
+        );
+
+        const options = { overwrite: true, workspaces: ['bar'] };
+        const result = await savedObjectsRepository.bulkCreate([obj1, obj, obj2], options);
+        expect(client.bulk).toHaveBeenCalled();
+        expect(client.mget).toHaveBeenCalled();
+
+        const body1 = {
+          docs: [
+            expect.objectContaining({ _id: `${obj1.type}:${obj1.id}` }),
+            expect.objectContaining({ _id: `${obj.type}:${obj.id}` }),
+            expect.objectContaining({ _id: `${obj2.type}:${obj2.id}` }),
+          ],
+        };
+        expect(client.mget).toHaveBeenCalledWith(
+          expect.objectContaining({ body: body1 }),
+          expect.anything()
+        );
+        const body2 = [...expectObjArgs(obj1)];
+        expect(client.bulk).toHaveBeenCalledWith(
+          expect.objectContaining({ body: body2 }),
+          expect.anything()
+        );
+        expect(result).toEqual({
+          saved_objects: [
+            expectSuccess(obj1),
+            expectErrorConflict(obj, { metadata: { isNotOverwritable: true } }),
+            expectErrorConflict(obj2, { metadata: { isNotOverwritable: true } }),
+          ],
+        });
+      });
     });
 
     describe('migration', () => {
@@ -1171,6 +1259,12 @@ describe('SavedObjectsRepository', () => {
         migrationVersion: doc._source.migrationVersion,
       });
 
+      it(`returns early for undefined objects argument`, async () => {
+        const result = await savedObjectsRepository.bulkGet();
+        expect(result).toEqual({ saved_objects: [] });
+        expect(client.mget).not.toHaveBeenCalled();
+      });
+
       it(`returns early for empty objects argument`, async () => {
         const result = await bulkGet([]);
         expect(result).toEqual({ saved_objects: [] });
@@ -1699,6 +1793,8 @@ describe('SavedObjectsRepository', () => {
     const obj5 = { type: MULTI_NAMESPACE_TYPE, id: 'five' };
     const obj6 = { type: NAMESPACE_AGNOSTIC_TYPE, id: 'six' };
     const obj7 = { type: NAMESPACE_AGNOSTIC_TYPE, id: 'seven' };
+    const obj8 = { type: 'dashboard', id: 'eight', workspaces: ['foo'] };
+    const obj9 = { type: 'dashboard', id: 'nine', workspaces: ['bar'] };
     const namespace = 'foo-namespace';
 
     const checkConflicts = async (objects, options) =>
@@ -1790,6 +1886,8 @@ describe('SavedObjectsRepository', () => {
             { found: false },
             getMockGetResponse(obj6),
             { found: false },
+            getMockGetResponse(obj7),
+            getMockGetResponse(obj8),
           ],
         };
         client.mget.mockResolvedValue(
@@ -1818,6 +1916,36 @@ describe('SavedObjectsRepository', () => {
           ],
         });
       });
+
+      it(`expected results with workspaces`, async () => {
+        const objects = [obj8, obj9];
+        const response = {
+          status: 200,
+          docs: [getMockGetResponse(obj8), getMockGetResponse(obj9)],
+        };
+        client.mget.mockResolvedValue(
+          opensearchClientMock.createSuccessTransportRequestPromise(response)
+        );
+
+        const result = await checkConflicts(objects, {
+          workspaces: ['foo'],
+        });
+        expect(client.mget).toHaveBeenCalledTimes(1);
+        expect(result).toEqual({
+          errors: [
+            { ...omitWorkspace(obj8), error: createConflictError(obj8.type, obj8.id) },
+            {
+              ...omitWorkspace(obj9),
+              error: {
+                ...createConflictError(obj9.type, obj9.id),
+                metadata: {
+                  isNotOverwritable: true,
+                },
+              },
+            },
+          ],
+        });
+      });
     });
   });
 
@@ -1846,9 +1974,17 @@ describe('SavedObjectsRepository', () => {
 
     const createSuccess = async (type, attributes, options) => {
       const result = await savedObjectsRepository.create(type, attributes, options);
-      expect(client.get).toHaveBeenCalledTimes(
-        registry.isMultiNamespace(type) && options.overwrite ? 1 : 0
-      );
+      let count = 0;
+      if (options?.overwrite && options.id && options.workspaces) {
+        /**
+         * workspace will call extra one to get latest status of current object
+         */
+        count++;
+      }
+      if (registry.isMultiNamespace(type) && options.overwrite) {
+        count++;
+      }
+      expect(client.get).toHaveBeenCalledTimes(count);
       return result;
     };
 
@@ -2040,6 +2176,29 @@ describe('SavedObjectsRepository', () => {
           expect.anything()
         );
       });
+
+      it(`doesn't modify workspaces when overwrite without target workspaces`, async () => {
+        const response = getMockGetResponse({ workspaces: ['foo'], id });
+        client.get.mockResolvedValueOnce(
+          opensearchClientMock.createSuccessTransportRequestPromise(response)
+        );
+
+        await savedObjectsRepository.create('dashboard', attributes, {
+          id,
+          overwrite: true,
+          workspaces: [],
+        });
+
+        expect(client.index).toHaveBeenCalledWith(
+          expect.objectContaining({
+            id: `dashboard:${id}`,
+            body: expect.objectContaining({
+              workspaces: ['foo'],
+            }),
+          }),
+          expect.anything()
+        );
+      });
     });
 
     describe('errors', () => {
@@ -2100,6 +2259,21 @@ describe('SavedObjectsRepository', () => {
         expect(client.get).toHaveBeenCalled();
       });
 
+      it(`throws error when there is a conflict with an existing workspaces saved object`, async () => {
+        const response = getMockGetResponse({ workspaces: ['foo'], id });
+        client.get.mockResolvedValueOnce(
+          opensearchClientMock.createSuccessTransportRequestPromise(response)
+        );
+        await expect(
+          savedObjectsRepository.create('dashboard', attributes, {
+            id,
+            overwrite: true,
+            workspaces: ['bar'],
+          })
+        ).rejects.toThrowError(createConflictError('dashboard', id));
+        expect(client.get).toHaveBeenCalled();
+      });
+
       it.todo(`throws when automatic index creation fails`);
 
       it.todo(`throws when an unexpected failure occurs`);
@@ -2186,10 +2360,11 @@ describe('SavedObjectsRepository', () => {
     const type = 'index-pattern';
     const id = 'logstash-*';
     const namespace = 'foo-namespace';
+    const workspaces = ['bar-workspace'];
 
     const deleteSuccess = async (type, id, options) => {
       if (registry.isMultiNamespace(type)) {
-        const mockGetResponse = getMockGetResponse({ type, id }, options?.namespace);
+        const mockGetResponse = getMockGetResponse({ type, id }, options?.namespace, workspaces);
         client.get.mockResolvedValueOnce(
           opensearchClientMock.createSuccessTransportRequestPromise(mockGetResponse)
         );
diff --git a/src/core/server/saved_objects/service/lib/repository.ts b/src/core/server/saved_objects/service/lib/repository.ts
index bccfd8ff2265..45997e6cf6b9 100644
--- a/src/core/server/saved_objects/service/lib/repository.ts
+++ b/src/core/server/saved_objects/service/lib/repository.ts
@@ -243,6 +243,7 @@ export class SavedObjectsRepository {
       originId,
       initialNamespaces,
       version,
+      workspaces,
     } = options;
     const namespace = normalizeNamespace(options.namespace);
 
@@ -279,6 +280,29 @@ export class SavedObjectsRepository {
       }
     }
 
+    let savedObjectWorkspaces = workspaces;
+
+    if (id && overwrite && workspaces) {
+      let currentItem;
+      try {
+        currentItem = await this.get(type, id);
+      } catch (e) {
+        // this.get will throw an error when no items can be found
+      }
+      if (currentItem) {
+        if (
+          SavedObjectsUtils.filterWorkspacesAccordingToSourceWorkspaces(
+            workspaces,
+            currentItem.workspaces
+          ).length
+        ) {
+          throw SavedObjectsErrorHelpers.createConflictError(type, id);
+        } else {
+          savedObjectWorkspaces = currentItem.workspaces;
+        }
+      }
+    }
+
     const migrated = this._migrator.migrateDocument({
       id,
       type,
@@ -289,6 +313,7 @@ export class SavedObjectsRepository {
       migrationVersion,
       updated_at: time,
       ...(Array.isArray(references) && { references }),
+      ...(Array.isArray(savedObjectWorkspaces) && { workspaces: savedObjectWorkspaces }),
     });
 
     const raw = this._serializer.savedObjectToRaw(migrated as SavedObjectSanitizedDoc);
@@ -355,15 +380,28 @@ export class SavedObjectsRepository {
 
       const method = object.id && overwrite ? 'index' : 'create';
       const requiresNamespacesCheck = object.id && this._registry.isMultiNamespace(object.type);
+      /**
+       * It requires a check when overwriting objects to target workspaces
+       */
+      const requiresWorkspaceCheck = !!(object.id && options.workspaces);
 
       if (object.id == null) object.id = uuid.v1();
 
+      let opensearchRequestIndexPayload = {};
+
+      if (requiresNamespacesCheck || requiresWorkspaceCheck) {
+        opensearchRequestIndexPayload = {
+          opensearchRequestIndex: bulkGetRequestIndexCounter,
+        };
+        bulkGetRequestIndexCounter++;
+      }
+
       return {
         tag: 'Right' as 'Right',
         value: {
           method,
           object,
-          ...(requiresNamespacesCheck && { opensearchRequestIndex: bulkGetRequestIndexCounter++ }),
+          ...opensearchRequestIndexPayload,
         },
       };
     });
@@ -374,7 +412,7 @@ export class SavedObjectsRepository {
       .map(({ value: { object: { type, id } } }) => ({
         _id: this._serializer.generateRawId(namespace, type, id),
         _index: this.getIndexForType(type),
-        _source: ['type', 'namespaces'],
+        _source: ['type', 'namespaces', 'workspaces'],
       }));
     const bulkGetResponse = bulkGetDocs.length
       ? await this.client.mget(
@@ -405,7 +443,7 @@ export class SavedObjectsRepository {
       if (opensearchRequestIndex !== undefined) {
         const indexFound = bulkGetResponse?.statusCode !== 404;
         const actualResult = indexFound
-          ? bulkGetResponse?.body.docs[opensearchRequestIndex]
+          ? bulkGetResponse?.body.docs?.[opensearchRequestIndex]
           : undefined;
         const docFound = indexFound && actualResult?.found === true;
         // @ts-expect-error MultiGetHit._source is optional
@@ -438,6 +476,50 @@ export class SavedObjectsRepository {
         versionProperties = getExpectedVersionProperties(version);
       }
 
+      let savedObjectWorkspaces: string[] | undefined = options.workspaces;
+
+      if (expectedBulkGetResult.value.method !== 'create') {
+        const rawId = this._serializer.generateRawId(namespace, object.type, object.id);
+        const findObject =
+          bulkGetResponse?.statusCode !== 404
+            ? bulkGetResponse?.body.docs?.find((item) => item._id === rawId)
+            : null;
+        /**
+         * When it is about to overwrite a object into options.workspace.
+         * We need to check if the options.workspaces is the subset of object.workspaces,
+         * Or it will be treated as a conflict
+         */
+        if (findObject && findObject.found) {
+          const transformedObject = this._serializer.rawToSavedObject(
+            findObject as SavedObjectsRawDoc
+          ) as SavedObject;
+          const filteredWorkspaces = SavedObjectsUtils.filterWorkspacesAccordingToSourceWorkspaces(
+            options.workspaces,
+            transformedObject.workspaces
+          );
+          if (filteredWorkspaces.length) {
+            /**
+             * options.workspaces is not a subset of object.workspaces,
+             * return a conflict error.
+             */
+            const { id, type } = object;
+            return {
+              tag: 'Left' as 'Left',
+              error: {
+                id,
+                type,
+                error: {
+                  ...errorContent(SavedObjectsErrorHelpers.createConflictError(type, id)),
+                  metadata: { isNotOverwritable: true },
+                },
+              },
+            };
+          } else {
+            savedObjectWorkspaces = transformedObject.workspaces;
+          }
+        }
+      }
+
       const expectedResult = {
         opensearchRequestIndex: bulkRequestIndexCounter++,
         requestedId: object.id,
@@ -452,6 +534,7 @@ export class SavedObjectsRepository {
             updated_at: time,
             references: object.references || [],
             originId: object.originId,
+            workspaces: savedObjectWorkspaces,
           }) as SavedObjectSanitizedDoc
         ),
       };
@@ -549,7 +632,7 @@ export class SavedObjectsRepository {
     const bulkGetDocs = expectedBulkGetResults.filter(isRight).map(({ value: { type, id } }) => ({
       _id: this._serializer.generateRawId(namespace, type, id),
       _index: this.getIndexForType(type),
-      _source: ['type', 'namespaces'],
+      _source: ['type', 'namespaces', 'workspaces'],
     }));
     const bulkGetResponse = bulkGetDocs.length
       ? await this.client.mget(
@@ -572,13 +655,24 @@ export class SavedObjectsRepository {
       const { type, id, opensearchRequestIndex } = expectedResult.value;
       const doc = bulkGetResponse?.body.docs[opensearchRequestIndex];
       if (doc?.found) {
+        let workspaceConflict = false;
+        if (options.workspaces) {
+          const transformedObject = this._serializer.rawToSavedObject(doc as SavedObjectsRawDoc);
+          const filteredWorkspaces = SavedObjectsUtils.filterWorkspacesAccordingToSourceWorkspaces(
+            options.workspaces,
+            transformedObject.workspaces
+          );
+          if (filteredWorkspaces.length) {
+            workspaceConflict = true;
+          }
+        }
         errors.push({
           id,
           type,
           error: {
             ...errorContent(SavedObjectsErrorHelpers.createConflictError(type, id)),
             // @ts-expect-error MultiGetHit._source is optional
-            ...(!this.rawDocExistsInNamespace(doc!, namespace) && {
+            ...((!this.rawDocExistsInNamespace(doc!, namespace) || workspaceConflict) && {
               metadata: { isNotOverwritable: true },
             }),
           },
@@ -717,6 +811,7 @@ export class SavedObjectsRepository {
    * @property {string} [options.namespace]
    * @property {object} [options.hasReference] - { type, id }
    * @property {string} [options.preference]
+   * @property {Array<string>} [options.workspaces]
    * @returns {promise} - { saved_objects: [{ id, type, version, attributes }], total, per_page, page }
    */
   async find<T = unknown>(options: SavedObjectsFindOptions): Promise<SavedObjectsFindResponse<T>> {
@@ -736,6 +831,7 @@ export class SavedObjectsRepository {
       typeToNamespacesMap,
       filter,
       preference,
+      workspaces,
     } = options;
 
     if (!type && !typeToNamespacesMap) {
@@ -809,6 +905,7 @@ export class SavedObjectsRepository {
           typeToNamespacesMap,
           hasReference,
           kueryNode,
+          workspaces,
         }),
       },
     };
@@ -862,7 +959,7 @@ export class SavedObjectsRepository {
    */
   async bulkGet<T = unknown>(
     objects: SavedObjectsBulkGetObject[] = [],
-    options: SavedObjectsBaseOptions = {}
+    options: Omit<SavedObjectsBaseOptions, 'workspaces'> = {}
   ): Promise<SavedObjectsBulkResponse<T>> {
     const namespace = normalizeNamespace(options.namespace);
 
@@ -950,7 +1047,7 @@ export class SavedObjectsRepository {
   async get<T = unknown>(
     type: string,
     id: string,
-    options: SavedObjectsBaseOptions = {}
+    options: Omit<SavedObjectsBaseOptions, 'workspaces'> = {}
   ): Promise<SavedObject<T>> {
     if (!this._allowedTypes.includes(type)) {
       throw SavedObjectsErrorHelpers.createGenericNotFoundError(type, id);
@@ -976,7 +1073,7 @@ export class SavedObjectsRepository {
       throw SavedObjectsErrorHelpers.createGenericNotFoundError(type, id);
     }
 
-    const { originId, updated_at: updatedAt } = body._source;
+    const { originId, updated_at: updatedAt, workspaces } = body._source;
 
     let namespaces: string[] = [];
     if (!this._registry.isNamespaceAgnostic(type)) {
@@ -991,6 +1088,7 @@ export class SavedObjectsRepository {
       namespaces,
       ...(originId && { originId }),
       ...(updatedAt && { updated_at: updatedAt }),
+      ...(workspaces && { workspaces }),
       version: encodeHitVersion(body),
       attributes: body._source[type],
       references: body._source.references || [],
@@ -1055,7 +1153,7 @@ export class SavedObjectsRepository {
       throw SavedObjectsErrorHelpers.createGenericNotFoundError(type, id);
     }
 
-    const { originId } = body.get?._source ?? {};
+    const { originId, workspaces } = body.get?._source ?? {};
     let namespaces: string[] = [];
     if (!this._registry.isNamespaceAgnostic(type)) {
       namespaces = body.get?._source.namespaces ?? [
@@ -1070,6 +1168,7 @@ export class SavedObjectsRepository {
       version: encodeHitVersion(body),
       namespaces,
       ...(originId && { originId }),
+      ...(workspaces && { workspaces }),
       references,
       attributes,
     };
@@ -1452,12 +1551,13 @@ export class SavedObjectsRepository {
           };
         }
 
-        const { originId } = get._source;
+        const { originId, workspaces } = get._source;
         return {
           id,
           type,
           ...(namespaces && { namespaces }),
           ...(originId && { originId }),
+          ...(workspaces && { workspaces }),
           updated_at,
           version: encodeVersion(seqNo, primaryTerm),
           attributes,
@@ -1754,7 +1854,7 @@ function getSavedObjectFromSource<T>(
   id: string,
   doc: { _seq_no?: number; _primary_term?: number; _source: SavedObjectsRawDocSource }
 ): SavedObject<T> {
-  const { originId, updated_at: updatedAt } = doc._source;
+  const { originId, updated_at: updatedAt, workspaces } = doc._source;
 
   let namespaces: string[] = [];
   if (!registry.isNamespaceAgnostic(type)) {
@@ -1769,6 +1869,7 @@ function getSavedObjectFromSource<T>(
     namespaces,
     ...(originId && { originId }),
     ...(updatedAt && { updated_at: updatedAt }),
+    ...(workspaces && { workspaces }),
     version: encodeHitVersion(doc),
     attributes: doc._source[type],
     references: doc._source.references || [],
diff --git a/src/core/server/saved_objects/service/lib/search_dsl/query_params.test.ts b/src/core/server/saved_objects/service/lib/search_dsl/query_params.test.ts
index 518e2ff56d0e..a47bc27fcd92 100644
--- a/src/core/server/saved_objects/service/lib/search_dsl/query_params.test.ts
+++ b/src/core/server/saved_objects/service/lib/search_dsl/query_params.test.ts
@@ -625,6 +625,27 @@ describe('#getQueryParams', () => {
         ]);
       });
     });
+
+    describe('when using workspace search', () => {
+      it('using normal workspaces', () => {
+        const result: Result = getQueryParams({
+          registry,
+          workspaces: ['foo'],
+        });
+        expect(result.query.bool.filter[1]).toEqual({
+          bool: {
+            should: [
+              {
+                bool: {
+                  must: [{ term: { workspaces: 'foo' } }],
+                },
+              },
+            ],
+            minimum_should_match: 1,
+          },
+        });
+      });
+    });
   });
 
   describe('namespaces property', () => {
diff --git a/src/core/server/saved_objects/service/lib/search_dsl/query_params.ts b/src/core/server/saved_objects/service/lib/search_dsl/query_params.ts
index 5bbb0a1fe24f..e660f299f460 100644
--- a/src/core/server/saved_objects/service/lib/search_dsl/query_params.ts
+++ b/src/core/server/saved_objects/service/lib/search_dsl/query_params.ts
@@ -127,6 +127,16 @@ function getClauseForType(
     },
   };
 }
+/**
+ *  Gets the clause that will filter for the workspace.
+ */
+function getClauseForWorkspace(workspace: string) {
+  return {
+    bool: {
+      must: [{ term: { workspaces: workspace } }],
+    },
+  };
+}
 
 interface HasReferenceQueryParams {
   type: string;
@@ -144,6 +154,7 @@ interface QueryParams {
   defaultSearchOperator?: string;
   hasReference?: HasReferenceQueryParams;
   kueryNode?: KueryNode;
+  workspaces?: string[];
 }
 
 export function getClauseForReference(reference: HasReferenceQueryParams) {
@@ -200,6 +211,7 @@ export function getQueryParams({
   defaultSearchOperator,
   hasReference,
   kueryNode,
+  workspaces,
 }: QueryParams) {
   const types = getTypes(
     registry,
@@ -224,6 +236,17 @@ export function getQueryParams({
     ],
   };
 
+  if (workspaces?.filter((workspace) => workspace).length) {
+    bool.filter.push({
+      bool: {
+        should: workspaces
+          .filter((workspace) => workspace)
+          .map((workspace) => getClauseForWorkspace(workspace)),
+        minimum_should_match: 1,
+      },
+    });
+  }
+
   if (search) {
     const useMatchPhrasePrefix = shouldUseMatchPhrasePrefix(search);
     const simpleQueryStringClause = getSimpleQueryStringClause({
diff --git a/src/core/server/saved_objects/service/lib/search_dsl/search_dsl.ts b/src/core/server/saved_objects/service/lib/search_dsl/search_dsl.ts
index 8b54141a4c3c..df6109eb9d0a 100644
--- a/src/core/server/saved_objects/service/lib/search_dsl/search_dsl.ts
+++ b/src/core/server/saved_objects/service/lib/search_dsl/search_dsl.ts
@@ -52,6 +52,7 @@ interface GetSearchDslOptions {
     id: string;
   };
   kueryNode?: KueryNode;
+  workspaces?: string[];
 }
 
 export function getSearchDsl(
@@ -71,6 +72,7 @@ export function getSearchDsl(
     typeToNamespacesMap,
     hasReference,
     kueryNode,
+    workspaces,
   } = options;
 
   if (!type) {
@@ -93,6 +95,7 @@ export function getSearchDsl(
       defaultSearchOperator,
       hasReference,
       kueryNode,
+      workspaces,
     }),
     ...getSortingParams(mappings, type, sortField, sortOrder),
   };
diff --git a/src/core/server/saved_objects/service/lib/utils.ts b/src/core/server/saved_objects/service/lib/utils.ts
index 4823e52d77c9..d3cb62e02b82 100644
--- a/src/core/server/saved_objects/service/lib/utils.ts
+++ b/src/core/server/saved_objects/service/lib/utils.ts
@@ -80,4 +80,11 @@ export class SavedObjectsUtils {
     total: 0,
     saved_objects: [],
   });
+
+  public static filterWorkspacesAccordingToSourceWorkspaces(
+    targetWorkspaces?: string[],
+    sourceWorkspaces?: string[]
+  ): string[] {
+    return targetWorkspaces?.filter((item) => !sourceWorkspaces?.includes(item)) || [];
+  }
 }
diff --git a/src/core/server/saved_objects/service/saved_objects_client.ts b/src/core/server/saved_objects/service/saved_objects_client.ts
index 5f92dacacf36..a087dc6c388a 100644
--- a/src/core/server/saved_objects/service/saved_objects_client.ts
+++ b/src/core/server/saved_objects/service/saved_objects_client.ts
@@ -363,7 +363,7 @@ export class SavedObjectsClient {
    */
   async bulkGet<T = unknown>(
     objects: SavedObjectsBulkGetObject[] = [],
-    options: SavedObjectsBaseOptions = {}
+    options: Omit<SavedObjectsBaseOptions, 'workspaces'> = {}
   ): Promise<SavedObjectsBulkResponse<T>> {
     return await this._repository.bulkGet(objects, options);
   }
diff --git a/src/core/server/saved_objects/types.ts b/src/core/server/saved_objects/types.ts
index 3e2553b8ce51..1b1409570fea 100644
--- a/src/core/server/saved_objects/types.ts
+++ b/src/core/server/saved_objects/types.ts
@@ -110,6 +110,8 @@ export interface SavedObjectsFindOptions {
   typeToNamespacesMap?: Map<string, string[] | undefined>;
   /** An optional OpenSearch preference value to be used for the query **/
   preference?: string;
+  /** If specified, will find all objects belong to specified workspaces **/
+  workspaces?: string[];
 }
 
 /**
@@ -119,6 +121,8 @@ export interface SavedObjectsFindOptions {
 export interface SavedObjectsBaseOptions {
   /** Specify the namespace for this operation */
   namespace?: string;
+  /** Specify the workspaces for this operation */
+  workspaces?: string[];
 }
 
 /**
diff --git a/src/core/types/saved_objects.ts b/src/core/types/saved_objects.ts
index 81e1ed029ddc..fa4f5ab97fdf 100644
--- a/src/core/types/saved_objects.ts
+++ b/src/core/types/saved_objects.ts
@@ -113,6 +113,8 @@ export interface SavedObject<T = unknown> {
    * space.
    */
   originId?: string;
+  /** Workspaces that this saved object exists in. */
+  workspaces?: string[];
 }
 
 export interface SavedObjectError {