diff --git a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/Airborne.kt b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/Airborne.kt
index b77c267e..e219c0e2 100644
--- a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/Airborne.kt
+++ b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/Airborne.kt
@@ -12,12 +12,20 @@ import javax.net.ssl.X509TrustManager
 
 @Keep
 class Airborne(
-    context: Context,
-    releaseConfigUrl: String,
-    private val airborneInterface: AirborneInterface
+    private val context: Context,
+    private val releaseConfigUrl: String,
+    private val airborneInterface: AirborneInterface,
+    private val shouldUpdate: Boolean
 ) {
 
-    constructor(context: Context, releaseConfigUrl: String) : this(context, releaseConfigUrl, object : AirborneInterface() {})
+    constructor(context: Context, releaseConfigUrl: String) : this(context, releaseConfigUrl, object : AirborneInterface() {}, true)
+
+    constructor(context: Context, releaseConfigUrl: String, airborneInterface: AirborneInterface) : this(
+        context,
+        releaseConfigUrl,
+        airborneInterface,
+        true
+    )
 
     /**
      * Default no-op TrackerCallback.
@@ -59,6 +67,7 @@ class Airborne(
 
     init {
         airborneObjectMap.put(airborneInterface.getNamespace(), this)
+        applicationManager.shouldUpdate = shouldUpdate
         applicationManager.loadApplication(airborneInterface.getNamespace(), airborneInterface.getLazyDownloadCallback())
     }
 
@@ -94,15 +103,13 @@ class Airborne(
     }
 
     /**
-     * Set custom SSL configuration for mTLS support.
-     * Call this before network requests are made to enable client certificate authentication.
-     *
-     * @param sslSocketFactory SSL socket factory configured with client certificate
-     * @param trustManager Trust manager for server certificate validation
+     * Checks for updates by fetching the remote RC and comparing with local.
+     * Uses the dimensions provided via AirborneInterface at init time.
+     * @return JSON string with update metadata.
      */
     @Keep
-    fun setSslConfig(sslSocketFactory: SSLSocketFactory, trustManager: X509TrustManager) {
-        applicationManager.setSslConfig(sslSocketFactory, trustManager)
+    fun checkForUpdate(): String {
+        return applicationManager.checkForUpdate()
     }
 
     companion object {
diff --git a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModule.kt b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModule.kt
index 17c62206..da3010f8 100644
--- a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModule.kt
+++ b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModule.kt
@@ -31,6 +31,11 @@ class AirborneModule(reactContext: ReactApplicationContext) :
     implementation.getBundlePath(namespace, promise)
   }
 
+  @ReactMethod
+  fun checkForUpdate(namespace: String, promise: Promise) {
+    implementation.checkForUpdate(namespace, promise)
+  }
+
   companion object {
     const val NAME = "Airborne"
   }
diff --git a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModuleImpl.kt b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModuleImpl.kt
index fceed5b3..10d7f50c 100644
--- a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModuleImpl.kt
+++ b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneModuleImpl.kt
@@ -68,4 +68,18 @@ class AirborneModuleImpl(private val reactContext: ReactApplicationContext) {
             promise.reject("AIRBORNE_ERROR", "Failed to get bundle path: ${e.message}", e)
         }
     }
+
+    fun checkForUpdate(namespace: String, promise: Promise) {
+        try {
+            val airborne = Airborne.airborneObjectMap[namespace]
+            if (airborne == null) {
+                promise.reject("UNKNOWN_NAMESPACE", "Namespace not found: $namespace")
+                return
+            }
+            val result = airborne.checkForUpdate()
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("AIRBORNE_ERROR", "Failed to check for update: ${e.message}", e)
+        }
+    }
 }
diff --git a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneTurboModule.kt b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneTurboModule.kt
index 04300ce4..0d681550 100644
--- a/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneTurboModule.kt
+++ b/airborne-react-native/android/src/main/java/in/juspay/airborneplugin/AirborneTurboModule.kt
@@ -26,6 +26,10 @@ class AirborneTurboModule(reactContext: ReactApplicationContext) :
     implementation.getBundlePath(nameSpace, promise)
   }
 
+  override fun checkForUpdate(nameSpace: String, promise: Promise) {
+    implementation.checkForUpdate(nameSpace, promise)
+  }
+
   companion object {
     const val NAME = "AirborneReact"
   }
diff --git a/airborne-react-native/example/src/App.tsx b/airborne-react-native/example/src/App.tsx
index e37518d7..0431e961 100644
--- a/airborne-react-native/example/src/App.tsx
+++ b/airborne-react-native/example/src/App.tsx
@@ -4,6 +4,7 @@ import {
   readReleaseConfig,
   getFileContent,
   getBundlePath,
+  checkForUpdate,
 } from 'airborne-react-native';
 
 export default function App() {
@@ -11,6 +12,7 @@ export default function App() {
   const [bundlePath, setBundlePath] = useState<string | undefined>();
   const [fileContent, setFileContent] = useState<string | undefined>();
   const [isInitialized, setIsInitialized] = useState(false);
+  const [updateMessage, setUpdateMessage] = useState("");
 
   // Airborne is initialized in native code (MainApplication.kt for Android, AppDelegate.swift for iOS)
   // This ensures the instance is ready before React Native starts
@@ -22,6 +24,15 @@ export default function App() {
       .catch(() => setIsInitialized(false));
   }, []);
 
+  const handleCheckForUpdate = async () => {
+    try {
+      const resp = await checkForUpdate("airborne-example");
+      setUpdateMessage(resp);
+    }catch(err: any) {
+      Alert.alert('Error', err.message || 'Failed to check for update');
+    }
+  }
+
   const handleReadReleaseConfig = async () => {
     try {
       const config = await readReleaseConfig("airborne-example");
@@ -66,6 +77,16 @@ export default function App() {
         )}
       </View>
 
+      <View style={styles.section}>
+        <Button
+          title="Check for update"
+          onPress={handleCheckForUpdate}
+        />
+        {updateMessage && (
+          <Text style={styles.result}>File Content: {updateMessage}</Text>
+        )}
+      </View>
+
       <View style={styles.section}>
         <Button title="Get Bundle Path" onPress={handleGetBundlePath} />
         {bundlePath && (
diff --git a/airborne-react-native/ios/Airborne.h b/airborne-react-native/ios/Airborne.h
index cc388427..75f3eaa5 100644
--- a/airborne-react-native/ios/Airborne.h
+++ b/airborne-react-native/ios/Airborne.h
@@ -8,10 +8,12 @@ NS_ASSUME_NONNULL_BEGIN
 + (instancetype)sharedInstanceWithNamespace:(NSString *)aNamespace;
 
 - (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate;
+- (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate shouldUpdate:(BOOL)shouldUpdate;
 
 - (NSString *)getBundlePath;
 - (NSString *)getFileContent:(NSString *)filePath;
 - (NSString *)getReleaseConfig;
+- (void)checkForUpdate:(void (^)(NSString * _Nonnull))completion;
 
 @end
 
diff --git a/airborne-react-native/ios/Airborne.m b/airborne-react-native/ios/Airborne.m
index 650089dd..84e242fe 100644
--- a/airborne-react-native/ios/Airborne.m
+++ b/airborne-react-native/ios/Airborne.m
@@ -5,7 +5,6 @@ @interface Airborne() <AirborneDelegate>
 
 @property (nonatomic, strong) NSString* namespace;
 @property (nonatomic, strong) AirborneServices* airborne;
-@property (nonatomic, weak) id <AirborneDelegate> delegate;
 
 @end
 
@@ -51,9 +50,13 @@ - (instancetype)initWithNamespace:(NSString *)namespace {
 }
 
 - (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate {
+    return [self initWithReleaseConfigURL:releaseConfigURL delegate:delegate shouldUpdate:YES];
+}
+
+- (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate shouldUpdate:(BOOL)shouldUpdate {
     self = [super init];
     if (self) {
-        self.airborne = [[AirborneServices alloc] initWithReleaseConfigURL:releaseConfigURL delegate:delegate ?: self];
+        self.airborne = [[AirborneServices alloc] initWithReleaseConfigURL:releaseConfigURL delegate:delegate ?: self shouldUpdate:shouldUpdate];
     }
     return self;
 }
@@ -70,6 +73,14 @@ - (NSString *)getReleaseConfig {
     return [self.airborne getReleaseConfig];
 }
 
+- (void)checkForUpdate:(void (^)(NSString * _Nonnull))completion {
+    if (!self.airborne) {
+        completion(@"{\"updateAvailable\":false,\"error\":\"Airborne is not initialized\"}");
+        return;
+    }
+    [self.airborne checkForUpdate:completion];
+}
+
 #pragma mark - AirborneDelegate
 
 - (NSString *)namespace {
@@ -77,4 +88,3 @@ - (NSString *)namespace {
 }
 
 @end
-
diff --git a/airborne-react-native/ios/AirborneReact.mm b/airborne-react-native/ios/AirborneReact.mm
index 8025632d..92035849 100644
--- a/airborne-react-native/ios/AirborneReact.mm
+++ b/airborne-react-native/ios/AirborneReact.mm
@@ -58,6 +58,18 @@ - (void)getBundlePath:(RCTPromiseResolveBlock)resolve
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
     }
 }
+
+- (void)checkForUpdate:(NSString *)nameSpace
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        [[Airborne sharedInstanceWithNamespace:nameSpace] checkForUpdate:^(NSString * _Nonnull result) {
+            resolve(result);
+        }];
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
 #else
 RCT_EXPORT_METHOD(readReleaseConfig:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
@@ -89,6 +101,18 @@ - (void)getBundlePath:(RCTPromiseResolveBlock)resolve
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
     }
 }
+
+RCT_EXPORT_METHOD(checkForUpdate:(NSString *)nameSpace
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        [[Airborne sharedInstanceWithNamespace:nameSpace] checkForUpdate:^(NSString * _Nonnull result) {
+            resolve(result);
+        }];
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
 #endif
 
 #ifdef RCT_NEW_ARCH_ENABLED
diff --git a/airborne-react-native/src/NativeAirborne.ts b/airborne-react-native/src/NativeAirborne.ts
index 67f767e4..174a2efb 100644
--- a/airborne-react-native/src/NativeAirborne.ts
+++ b/airborne-react-native/src/NativeAirborne.ts
@@ -19,6 +19,7 @@ export interface Spec extends TurboModule {
   readReleaseConfig(nameSpace: string): Promise<string>;
   getFileContent(nameSpace: string, filePath: string): Promise<string>;
   getBundlePath(nameSpace: string): Promise<string>;
+  checkForUpdate(nameSpace: string): Promise<string>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('Airborne');
diff --git a/airborne-react-native/src/index.tsx b/airborne-react-native/src/index.tsx
index 398b958b..3571db6c 100644
--- a/airborne-react-native/src/index.tsx
+++ b/airborne-react-native/src/index.tsx
@@ -50,4 +50,8 @@ export function getBundlePath(nameSpace: string): Promise<string> {
   return Airborne.getBundlePath(nameSpace);
 }
 
+export function checkForUpdate(nameSpace: string): Promise<string> {
+  return Airborne.checkForUpdate(nameSpace);
+}
+
 export default Airborne;
diff --git a/airborne_sdk_android/airborne/src/main/java/in/juspay/airborne/ota/ApplicationManager.kt b/airborne_sdk_android/airborne/src/main/java/in/juspay/airborne/ota/ApplicationManager.kt
index b5992373..920e181a 100644
--- a/airborne_sdk_android/airborne/src/main/java/in/juspay/airborne/ota/ApplicationManager.kt
+++ b/airborne_sdk_android/airborne/src/main/java/in/juspay/airborne/ota/ApplicationManager.kt
@@ -36,6 +36,7 @@ import `in`.juspay.airborne.constants.LogSubCategory
 import org.json.JSONArray
 import org.json.JSONObject
 import java.lang.ref.WeakReference
+import java.net.HttpURLConnection.HTTP_OK
 import java.util.concurrent.Callable
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentMap
@@ -423,6 +424,77 @@ class ApplicationManager(
         return releaseConfig?.serialize() ?: ""
     }
 
+    fun checkForUpdate(): String {
+        val url = if (releaseConfigTemplateUrl == "") {
+            rcCallback?.getReleaseConfig(false) ?: ""
+        } else {
+            releaseConfigTemplateUrl
+        }
+
+        if (url.isEmpty()) {
+            return JSONObject()
+                .put("updateAvailable", false)
+                .put("error", "No release config URL")
+                .toString()
+        }
+
+        val localRc = releaseConfig
+        val headers = mutableMapOf("cache-control" to "no-cache")
+        localRc?.let {
+            headers["x-release-config-version"] = it.version
+            headers["x-package-version"] = it.pkg.version
+            headers["x-config-version"] = it.config.version
+        }
+
+        val sortedDimensions = (rcHeaders ?: emptyMap()).toSortedMap()
+        if (sortedDimensions.isNotEmpty()) {
+            headers["x-dimension"] =
+                sortedDimensions.entries.joinToString(";") { "${it.key}=${it.value}" }
+        }
+
+        val clientId =
+            sanitizeClientId(otaServices.clientId?.takeIf { it.isNotBlank() } ?: "default")
+        val releaseConfigNetUtils = OTANetUtils(ctx, clientId, otaServices.cleanUpValue)
+
+        return try {
+            val resp = releaseConfigNetUtils.doGet(url, headers, null, null, null)
+            val code = resp.code()
+            val body = resp.body()
+
+            if (code != HTTP_OK || body == null) {
+                resp.close()
+                JSONObject()
+                    .put("updateAvailable", false)
+                    .put("error", "HTTP $code")
+                    .toString()
+            } else {
+                val remoteJson = JSONObject(body.string())
+                resp.close()
+
+                val localVersion = localRc?.config?.version ?: ""
+                val localPkgVersion = localRc?.pkg?.version ?: ""
+                val remoteVersion =
+                    remoteJson.optJSONObject("config")?.optString("version", "") ?: ""
+                val remotePkgVersion =
+                    remoteJson.optJSONObject("package")?.optString("version", "") ?: ""
+
+                JSONObject()
+                    .put("updateAvailable", remoteVersion != localVersion)
+                    .put("currentVersion", localVersion)
+                    .put("remoteVersion", remoteVersion)
+                    .put("currentPackageVersion", localPkgVersion)
+                    .put("remotePackageVersion", remotePkgVersion)
+                    .toString()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "checkForUpdate failed", e)
+            JSONObject()
+                .put("updateAvailable", false)
+                .put("error", e.message ?: "Unknown error")
+                .toString()
+        }
+    }
+
     private fun trackUpdateResult(updateResult: UpdateResult) {
         val result = when (updateResult) {
             is UpdateResult.Ok -> "OK"
diff --git a/airborne_sdk_iOS/hyper-ota/Airborne/AirborneSwift/Airborne.swift b/airborne_sdk_iOS/hyper-ota/Airborne/AirborneSwift/Airborne.swift
index f90e76d8..abab2fbb 100644
--- a/airborne_sdk_iOS/hyper-ota/Airborne/AirborneSwift/Airborne.swift
+++ b/airborne_sdk_iOS/hyper-ota/Airborne/AirborneSwift/Airborne.swift
@@ -314,6 +314,90 @@ extension AirborneServices {
             return ""
         }
     }
+
+    @objc public func checkForUpdate(_ completion: @escaping (String) -> Void) {
+        let serializeResult: ([String: Any]) -> String = { result in
+            guard JSONSerialization.isValidJSONObject(result),
+                  let jsonData = try? JSONSerialization.data(withJSONObject: result),
+                  let jsonString = String(data: jsonData, encoding: .utf8) else {
+                return "{\"updateAvailable\":false,\"error\":\"Failed to serialize result\"}"
+            }
+            return jsonString
+        }
+
+        guard !self.releaseConfigURL.isEmpty else {
+            completion(serializeResult(["updateAvailable": false, "error": "No release config URL"]))
+            return
+        }
+
+        guard let url = URL(string: self.releaseConfigURL) else {
+            completion(serializeResult(["updateAvailable": false, "error": "Invalid release config URL"]))
+            return
+        }
+
+        let localRCJson = self.getReleaseConfig()
+        let localData = localRCJson.data(using: .utf8) ?? Data()
+        let localDict = (try? JSONSerialization.jsonObject(with: localData)) as? [String: Any]
+        let localConfig = localDict?["config"] as? [String: Any]
+        let localPackage = localDict?["package"] as? [String: Any]
+        let localRCVersion = localDict?["version"] as? String ?? ""
+        let localVersion = localConfig?["version"] as? String ?? ""
+        let localPkgVersion = localPackage?["version"] as? String ?? ""
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("no-cache", forHTTPHeaderField: "cache-control")
+        request.setValue(localRCVersion, forHTTPHeaderField: "x-release-config-version")
+        request.setValue(localPkgVersion, forHTTPHeaderField: "x-package-version")
+        request.setValue(localVersion, forHTTPHeaderField: "x-config-version")
+
+        if !self.dimensions.isEmpty {
+            let dimensionString = self.dimensions.sorted { $0.key < $1.key }
+                .map { "\($0.key)=\($0.value)" }
+                .joined(separator: ";")
+            request.setValue(dimensionString, forHTTPHeaderField: "x-dimension")
+        }
+
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(serializeResult(["updateAvailable": false, "error": error.localizedDescription]))
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                completion(serializeResult(["updateAvailable": false, "error": "Invalid HTTP response"]))
+                return
+            }
+
+            guard httpResponse.statusCode == 200, let data = data else {
+                completion(serializeResult(["updateAvailable": false, "error": "HTTP \(httpResponse.statusCode)"]))
+                return
+            }
+
+            guard let remoteDict = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
+                completion(serializeResult(["updateAvailable": false, "error": "Failed to parse release config"]))
+                return
+            }
+
+            let remoteConfig = remoteDict["config"] as? [String: Any]
+            let remotePackage = remoteDict["package"] as? [String: Any]
+            let remoteVersion = remoteConfig?["version"] as? String ?? ""
+            let remotePkgVersion = remotePackage?["version"] as? String ?? ""
+
+            completion(
+                serializeResult(
+                    [
+                        "updateAvailable": remoteVersion != localVersion,
+                        "currentVersion": localVersion,
+                        "remoteVersion": remoteVersion,
+                        "currentPackageVersion": localPkgVersion,
+                        "remotePackageVersion": remotePkgVersion
+                    ]
+                )
+            )
+        }
+        task.resume()
+    }
     
     /**
      * Reads and returns the content of a package file.