diff --git a/js-miniapp-sdk/src/miniapp.ts b/js-miniapp-sdk/src/miniapp.ts
index ead25d52..ac42d591 100644
--- a/js-miniapp-sdk/src/miniapp.ts
+++ b/js-miniapp-sdk/src/miniapp.ts
@@ -15,7 +15,7 @@ import {
 } from '../../js-miniapp-bridge/src';
 import { UserInfoProvider, UserInfo } from './modules/user-info';
 import { ChatService } from './modules/chat-service';
-import { getBridge } from './sdkbridge';
+import { getBridge, setMockMiniAppData } from './sdkbridge';
 import { SecureStorageService } from './modules/secure-storage';
 import { UniversalBridge } from './modules/universal-bridge';
 import { MiniAppUtils } from './modules/utils';
@@ -27,6 +27,7 @@ import { GalleryBridge } from './modules/gallery-manager';
 import { ShareInfoType } from './types/share-info';
 import { WebviewManager } from './modules/webview-config-provider';
 import { Esim } from './modules/e-sim';
+import { MockMiniAppData } from './mock/mock-miniapp';
 
 /**
  * A module layer for webapps and mobile native interaction.
@@ -303,4 +304,13 @@ export class MiniApp implements MiniAppFeatures, Ad, Platform {
   setCloseAlert(alertInfo: CloseAlertInfo): Promise<string> {
     return getBridge().setCloseAlert(alertInfo);
   }
+
+  setMockData(data: MockMiniAppData): Promise<string> {
+    try {
+      setMockMiniAppData(data);
+      return Promise.resolve('success');
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
 }
diff --git a/js-miniapp-sdk/src/mock-bridge.ts b/js-miniapp-sdk/src/mock-bridge.ts
new file mode 100644
index 00000000..9ecd5416
--- /dev/null
+++ b/js-miniapp-sdk/src/mock-bridge.ts
@@ -0,0 +1,477 @@
+import { HostEnvironmentInfo } from '../../js-miniapp-bridge/src/types/host-environment-info';
+import { MiniAppError, Platform, Points } from '../../js-miniapp-bridge/src';
+import { UserProfileManager } from '../../js-miniapp-bridge/src/modules/userprofile-manager';
+import { BrowserManager } from '../../js-miniapp-bridge/src/modules/browser-manager';
+import { mockMiniAppData } from './sdkbridge';
+import { UtitlityManager } from '../../js-miniapp-bridge/src/modules/utility-manager';
+
+/** @internal */
+export class MockBridge {
+  platform: string;
+  userProfileManager: UserProfileManager;
+  browserManager: BrowserManager;
+  utilityManager: UtitlityManager;
+  isSecureStorageReady = false;
+  secureStorageLoadError: MiniAppError | null = null;
+
+  constructor() {
+    this.platform = Platform.IOS;
+    this.userProfileManager = undefined;
+    this.browserManager = undefined;
+    this.utilityManager = undefined;
+  }
+
+  getPlatform() {
+    return mockMiniAppData.platform;
+  }
+
+  getAccessToken() {
+    return Promise.resolve(mockMiniAppData.token).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getHostEnvironmentInfo(): Promise<HostEnvironmentInfo> {
+    return Promise.resolve(mockMiniAppData.hostEnvInfo).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getAllCookies() {
+    return Promise.resolve(mockMiniAppData.allCookies).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getFeatureList() {
+    return Promise.resolve(mockMiniAppData.features).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getUserName() {
+    return Promise.resolve(mockMiniAppData.userName).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getProfilePhoto() {
+    return Promise.resolve(mockMiniAppData.profilePic).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getPhoneNumber() {
+    return Promise.resolve(mockMiniAppData.phoneNo).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  requestPermission() {
+    if (mockMiniAppData.requestPermission) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  getUniqueId() {
+    return Promise.resolve(mockMiniAppData.uniqueId).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getMessagingUniqueId() {
+    return Promise.resolve(mockMiniAppData.messagingUniqueId).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getMauid() {
+    return Promise.resolve(mockMiniAppData.mauid).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  requestLocationPermission() {
+    if (mockMiniAppData.requestLocationPermission) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  requestCustomPermissions() {
+    return Promise.resolve(mockMiniAppData.permissionInfo).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  loadInterstitialAd() {
+    if (mockMiniAppData.loadInterstitialAd) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  loadRewardedAd() {
+    if (mockMiniAppData.loadRewardedAd) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  showInterstitialAd() {
+    if (mockMiniAppData.showInterstitialAd) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  showRewardedAd() {
+    return Promise.resolve(mockMiniAppData.rewardAdResponse).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  shareInfo() {
+    if (mockMiniAppData.shareInfo) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  setScreenOrientation() {
+    if (mockMiniAppData.setScreenOrientation) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  sendMessageToContact() {
+    try {
+      if (
+        mockMiniAppData.contactId !== 'null' &&
+        mockMiniAppData.contactId !== null
+      ) {
+        return Promise.resolve(mockMiniAppData.contactId);
+      } else {
+        return Promise.resolve(null);
+      }
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  sendMessageToContactId() {
+    try {
+      if (
+        mockMiniAppData.contactId !== 'null' &&
+        mockMiniAppData.contactId !== null
+      ) {
+        return Promise.resolve(mockMiniAppData.contactId);
+      } else {
+        return Promise.resolve(null);
+      }
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  sendMessageToMultipleContacts() {
+    try {
+      if (
+        mockMiniAppData.contactId !== 'null' &&
+        mockMiniAppData.contactId !== null
+      ) {
+        return Promise.resolve(
+          JSON.parse(mockMiniAppData.contactId) as string[]
+        );
+      } else {
+        return Promise.resolve(null);
+      }
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  getPoints() {
+    return Promise.resolve(JSON.parse(mockMiniAppData.points) as Points).catch(
+      e => {
+        return Promise.reject(e);
+      }
+    );
+  }
+
+  downloadFile() {
+    try {
+      if (
+        mockMiniAppData.fileDowloadId !== 'null' &&
+        mockMiniAppData.fileDowloadId !== null
+      ) {
+        return Promise.resolve(
+          JSON.parse(mockMiniAppData.fileDowloadId) as string[]
+        );
+      } else {
+        return Promise.resolve(null);
+      }
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  setSecureStorage() {
+    return Promise.resolve(undefined).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getSecureStorageItem() {
+    return Promise.resolve(mockMiniAppData.secureStorageItem).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  removeSecureStorageItems() {
+    return Promise.resolve(undefined).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  clearSecureStorage() {
+    return Promise.resolve(undefined).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getSecureStorageSize() {
+    return Promise.resolve(mockMiniAppData.secureStorageSize).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  setCloseAlert() {
+    if (mockMiniAppData.setCloseAlert) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  sendJsonToHostapp() {
+    if (mockMiniAppData.sendJsonToHostapp) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  sendInfoToHostapp() {
+    if (mockMiniAppData.sendInfoToHostapp) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  getContacts() {
+    return Promise.resolve(mockMiniAppData.contacts).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  isLoggedIn() {
+    return Promise.resolve(mockMiniAppData.isLoggedIn).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  closeMiniApp() {
+    if (mockMiniAppData.closeMiniApp) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  miniAppFinishedLoading() {
+    if (mockMiniAppData.miniAppFinishedLoading) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  getAllProducts() {
+    return Promise.resolve(mockMiniAppData.productsList).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  purchaseProductWith() {
+    return Promise.resolve(mockMiniAppData.productInfo).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  consumePurchaseWith() {
+    return Promise.resolve(mockMiniAppData.consumedPurchaseInfo).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getHostAppThemeColors() {
+    return Promise.resolve(mockMiniAppData.themeColor).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  isDarkMode() {
+    return Promise.resolve(mockMiniAppData.isDarkMode).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  sendAnalytics() {
+    if (mockMiniAppData.sendAnalytics) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  shouldClearNotifications() {
+    if (mockMiniAppData.shouldClearNotifications) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  shouldUpdateBadgeNumber() {
+    if (mockMiniAppData.shouldUpdateBadgeNumber) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  shouldUpdateNotificationInfo() {
+    if (mockMiniAppData.shouldUpdateNotificationInfo) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  canOpenAppDeeplink() {
+    return Promise.resolve(mockMiniAppData.openAppDeeplink).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  isAppDeeplinkSupported() {
+    return Promise.reject(false);
+  }
+
+  launchExternalBrowser() {
+    return Promise.resolve(mockMiniAppData.launchExternalBrowser).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  launchInternalBrowser() {
+    return Promise.resolve(mockMiniAppData.launchInternalBrowser).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  launchGallery() {
+    return Promise.resolve(mockMiniAppData.launchGallery).catch(() => {
+      return Promise.reject(false);
+    });
+  }
+
+  getCookies() {
+    return Promise.resolve(mockMiniAppData.cookies).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  set() {
+    if (mockMiniAppData.setPreferences) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  get() {
+    if (mockMiniAppData.getPreferences) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  remove() {
+    if (mockMiniAppData.removePreferences) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  clearMiniAppPreferences() {
+    if (mockMiniAppData.clearMiniAppPreferences) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  getImageFromGallery() {
+    return Promise.resolve(mockMiniAppData.getImageFromGallery).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  getExchangeToken() {
+    return Promise.resolve(mockMiniAppData.exchangeToken).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  logEvent() {
+    if (mockMiniAppData.logEvent) {
+      return Promise.resolve('success');
+    } else {
+      return Promise.reject();
+    }
+  }
+
+  allowBackForwardNavigationGestures() {
+    return Promise.resolve(
+      mockMiniAppData.allowBackForwardNavigationGestures
+    ).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  isEsimSupported() {
+    return Promise.resolve(mockMiniAppData.isEsimSupported).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+
+  setupAndInstallEsim() {
+    return Promise.resolve(mockMiniAppData.setupAndInstallEsim).catch(e => {
+      return Promise.reject(e);
+    });
+  }
+}
diff --git a/js-miniapp-sdk/src/mock/mock-miniapp.ts b/js-miniapp-sdk/src/mock/mock-miniapp.ts
new file mode 100644
index 00000000..4fdad4c3
--- /dev/null
+++ b/js-miniapp-sdk/src/mock/mock-miniapp.ts
@@ -0,0 +1,76 @@
+import {
+  AccessTokenData,
+  Contact,
+  CookieInfo,
+  HostEnvironmentInfo,
+  HostThemeColor,
+  MiniAppSecureStorageSize,
+  Platform,
+  ProductInfo,
+  PurchasedProductInfo,
+  Reward,
+} from '../../../js-miniapp-bridge/src';
+import { CustomPermissionResponse } from '../../../js-miniapp-bridge/src/types/custom-permissions';
+import { MiniAppResponseInfo } from '../../../js-miniapp-bridge/src/types/response-types/miniapp';
+import { GalleryFileInfo } from '../../../js-miniapp-bridge/src/types/share-info';
+
+export interface MockMiniAppData {
+  isMockEnabled: boolean;
+  platform?: Platform.ANDROID | Platform.IOS;
+  token?: AccessTokenData;
+  hostEnvInfo?: HostEnvironmentInfo;
+  allCookies?: [CookieInfo];
+  cookies?: [CookieInfo];
+  features?: string[];
+  userName?: string;
+  profilePic?: string;
+  phoneNo?: string;
+  uniqueId?: string;
+  messagingUniqueId?: string;
+  mauid?: string;
+  permissionInfo?: CustomPermissionResponse;
+  rewardAdResponse?: Reward;
+  contactId?: string;
+  points?: string;
+  fileDowloadId?: string;
+  secureStorageItem?: string;
+  secureStorageSize?: MiniAppSecureStorageSize;
+  contacts?: Contact[];
+  isLoggedIn?: boolean;
+  miniAppFinishedLoading?: string;
+  closeMiniApp?: boolean;
+  productsList?: ProductInfo[];
+  productInfo?: PurchasedProductInfo;
+  consumedPurchaseInfo?: MiniAppResponseInfo;
+  themeColor?: HostThemeColor;
+  isDarkMode?: boolean;
+  openAppDeeplink?: boolean;
+  launchExternalBrowser?: string;
+  launchInternalBrowser?: string;
+  launchGallery?: string;
+  preference?: string;
+  requestPermission?: boolean;
+  requestLocationPermission?: boolean;
+  loadInterstitialAd?: boolean;
+  showInterstitialAd?: boolean;
+  loadRewardedAd?: boolean;
+  shareInfo?: boolean;
+  setScreenOrientation?: boolean;
+  setCloseAlert?: boolean;
+  sendJsonToHostapp?: boolean;
+  sendInfoToHostapp?: boolean;
+  sendAnalytics?: boolean;
+  shouldClearNotifications?: boolean;
+  shouldUpdateBadgeNumber?: boolean;
+  shouldUpdateNotificationInfo?: boolean;
+  setPreferences?: boolean;
+  getPreferences?: boolean;
+  removePreferences?: boolean;
+  clearMiniAppPreferences?: boolean;
+  getImageFromGallery?: GalleryFileInfo;
+  exchangeToken?: AccessTokenData;
+  logEvent?: boolean;
+  allowBackForwardNavigationGestures?: boolean;
+  isEsimSupported?: boolean;
+  setupAndInstallEsim?: boolean;
+}
diff --git a/js-miniapp-sdk/src/sdkbridge.ts b/js-miniapp-sdk/src/sdkbridge.ts
index 794bbae0..254a194b 100644
--- a/js-miniapp-sdk/src/sdkbridge.ts
+++ b/js-miniapp-sdk/src/sdkbridge.ts
@@ -1,7 +1,24 @@
 import { MiniAppBridge } from '../../js-miniapp-bridge/src';
+import { MockBridge } from './mock-bridge';
+import { MockMiniAppData } from './mock/mock-miniapp';
+
+export let mockMiniAppData: MockMiniAppData = { isMockEnabled: false };
+
+export function setMockMiniAppData(mockData: MockMiniAppData) {
+  mockMiniAppData = mockData;
+}
 
 /** @internal */
 export function getBridge() {
   // tslint:disable:no-any
-  return (window as any).MiniAppBridge as MiniAppBridge;
+  const bridge = (window as any).MiniAppBridge as MiniAppBridge;
+  if (
+    mockMiniAppData &&
+    mockMiniAppData.isMockEnabled &&
+    bridge === undefined
+  ) {
+    const obj: MockBridge = new MockBridge();
+    return obj;
+  }
+  return bridge;
 }