diff --git a/frameworks/kits/js/common/image_creator_napi.cpp b/frameworks/kits/js/common/image_creator_napi.cpp
index 3c441ab08a09b21eb8c2607650af55c2eb01c73b..aa0678b46ad02ee60a36ebfe84bf33a018fecad1 100644
--- a/frameworks/kits/js/common/image_creator_napi.cpp
+++ b/frameworks/kits/js/common/image_creator_napi.cpp
@@ -207,6 +207,31 @@ void ImageCreatorNapi::Destructor(napi_env env, void *nativeObject, void *finali
 {
 }
 
+napi_value ImageCreatorNapi::CreateImageCreator(napi_env env, std::shared_ptr<ImageCreator> imageCreator)
+{
+    if (sConstructor_ == nullptr) {
+        napi_value exports = nullptr;
+        napi_create_object(env, &exports);
+        ImageCreatorNapi::Init(env, exports);
+    }
+    napi_value result = nullptr;
+    IMG_NAPI_CHECK_RET_D(imageCreator != nullptr, result,
+        IMAGE_LOGE("%{public}s imageCreator is nullptr", __func__));
+    std::unique_ptr<ImageCreatorNapi> obj = std::make_unique<ImageCreatorNapi>();
+    IMG_NAPI_CHECK_RET_D(obj != nullptr, result, IMAGE_LOGE("%{public}s no memory", __func__));
+    obj->imageCreator_ = imageCreator;
+    napi_status status = napi_wrap(env, result, reinterpret_cast<void *>(obj.get()),
+        ImageCreatorNapi::Destructor, nullptr, nullptr);
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), result, IMAGE_LOGE("%{public}s napi_wrap failed", __func__));
+    obj.release();
+    return result;
+}
+
+std::shared_ptr<ImageCreator> ImageCreatorNapi::GetNativeImageCreator()
+{
+    return imageCreator_;
+}
+
 static bool isTest(const int32_t* args, const int32_t len)
 {
     if ((args[PARAM0] ==  TEST_WIDTH) &&
diff --git a/frameworks/kits/js/common/image_packer_napi.cpp b/frameworks/kits/js/common/image_packer_napi.cpp
index 3d47cbb5b68c411c9bca12fec535238956645e6a..9403d96a4e7aec81c21044f06fd44521a5e87cd3 100644
--- a/frameworks/kits/js/common/image_packer_napi.cpp
+++ b/frameworks/kits/js/common/image_packer_napi.cpp
@@ -551,6 +551,33 @@ napi_value ImagePackerNapi::CreateImagePacker(napi_env env, napi_callback_info i
     return result;
 }
 
+napi_value ImagePackerNapi::CreateImagePackerNapi(napi_env env, std::shared_ptr<ImagePacker> imagePacker)
+{
+    if (sConstructor_ == nullptr) {
+        napi_value exports = nullptr;
+        napi_create_object(env, &exports);
+        ImagePackerNapi::Init(env, exports);
+    }
+    napi_value constructor = nullptr;
+    napi_value result = nullptr;
+    napi_status status = napi_get_reference_value(env, sConstructor_, &constructor);
+    if (IMG_IS_OK(status)) {
+        if (imagePacker != nullptr) {
+            sImgPck_ = std::move(imagePacker);
+            status = napi_new_instance(env, constructor, NUM_0, nullptr, &result);
+        } else {
+            status = napi_invalid_arg;
+            IMAGE_LOGE("New ImagePackerNapi Instance imagePacker is nullptr");
+            napi_get_undefined(env, &result);
+        }
+    }
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("CreateImagePacker | New instance could not be obtained");
+        napi_get_undefined(env, &result);
+    }
+    return result;
+}
+
 void ImagePackerNapi::Destructor(napi_env env, void *nativeObject, void *finalize)
 {
 }
diff --git a/frameworks/kits/js/common/image_receiver_napi.cpp b/frameworks/kits/js/common/image_receiver_napi.cpp
index e27e4fdea664d8c9995490bc3e95d966f97e6e48..1c8131ae5b8d51f48ef9b28dddeaab7ff01afe0a 100644
--- a/frameworks/kits/js/common/image_receiver_napi.cpp
+++ b/frameworks/kits/js/common/image_receiver_napi.cpp
@@ -138,6 +138,12 @@ ImageReceiver* ImageReceiverNapi::GetNative()
     }
     return nullptr;
 }
+
+std::shared_ptr<ImageReceiver> ImageReceiverNapi::GetNativeImageReceiver()
+{
+    return imageReceiver_;
+}
+
 napi_value ImageReceiverNapi::Init(napi_env env, napi_value exports)
 {
     IMAGE_FUNCTION_IN();
@@ -260,6 +266,26 @@ void ImageReceiverNapi::Destructor(napi_env env, void *nativeObject, void *final
     }
 }
 
+napi_value ImageReceiverNapi::CreateImageReceiver(napi_env env, std::shared_ptr<ImageReceiver> imageReceiver)
+{
+    if (sConstructor_ == nullptr) {
+        napi_value exports = nullptr;
+        napi_create_object(env, &exports);
+        ImageReceiverNapi::Init(env, exports);
+    }
+    napi_value result = nullptr;
+    IMG_NAPI_CHECK_RET_D(imageReceiver != nullptr, result,
+        IMAGE_LOGE("%{public}s imageReceiver is nullptr", __func__));
+    std::unique_ptr<ImageReceiverNapi> obj = std::make_unique<ImageReceiverNapi>();
+    IMG_NAPI_CHECK_RET_D(obj != nullptr, result, IMAGE_LOGE("%{public}s no memory", __func__));
+    obj->imageReceiver_ = imageReceiver;
+    napi_status status = napi_wrap(env, result, reinterpret_cast<void *>(obj.get()),
+        ImageReceiverNapi::Destructor, nullptr, nullptr);
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), result, IMAGE_LOGE("%{public}s napi_wrap failed", __func__));
+    obj.release();
+    return result;
+}
+
 static bool checkFormat(int32_t format)
 {
     for (auto imgEnum : sImageFormatMap) {
diff --git a/frameworks/kits/js/common/image_source_napi.cpp b/frameworks/kits/js/common/image_source_napi.cpp
index 71023fd1905ee808524c13a27b0644fb4472d371..1b207af71c4f0dd1b163028349d5cfa8e9fed51f 100644
--- a/frameworks/kits/js/common/image_source_napi.cpp
+++ b/frameworks/kits/js/common/image_source_napi.cpp
@@ -3255,6 +3255,33 @@ int32_t ImageSourceNapi::CreateImageSourceNapi(napi_env env, napi_value* result)
     return SUCCESS;
 }
 
+napi_value ImageSourceNapi::CreateImageSourceNapi(napi_env env, std::shared_ptr<ImageSource> imageSource)
+{
+    if (sConstructor_ == nullptr) {
+        napi_value exports = nullptr;
+        napi_create_object(env, &exports);
+        ImageSourceNapi::Init(env, exports);
+    }
+    napi_value constructor = nullptr;
+    napi_value result = nullptr;
+    napi_status status = napi_get_reference_value(env, sConstructor_, &constructor);
+    if (IMG_IS_OK(status)) {
+        if (imageSource != nullptr) {
+            sImgSrc_ = std::move(imageSource);
+            status = napi_new_instance(env, constructor, NUM_0, nullptr, &result);
+        } else {
+            status = napi_invalid_arg;
+            IMAGE_LOGE("New ImageSourceNapi Instance imageSource is nullptr");
+            napi_get_undefined(env, &result);
+        }
+    }
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("CreateImageSource | New instance could not be obtained");
+        napi_get_undefined(env, &result);
+    }
+    return result;
+}
+
 void ImageSourceNapi::SetIncrementalPixelMap(std::shared_ptr<IncrementalPixelMap> incrementalPixelMap)
 {
     navIncPixelMap_ = incrementalPixelMap;
diff --git a/frameworks/kits/js/common/picture_napi.cpp b/frameworks/kits/js/common/picture_napi.cpp
index 13471f6c632d42c769a5149e1084f480685aa0f7..9ddd7339298bea8621e3c8c1b26344664c086c2a 100644
--- a/frameworks/kits/js/common/picture_napi.cpp
+++ b/frameworks/kits/js/common/picture_napi.cpp
@@ -417,6 +417,11 @@ void PictureNapi::SetNativePicture(std::shared_ptr<Picture> picture)
     nativePicture_ = picture;
 }
 
+std::shared_ptr<Picture> PictureNapi::GetNativePicture()
+{
+    return nativePicture_;
+}
+
 napi_value PictureNapi::GetAuxiliaryPicture(napi_env env, napi_callback_info info)
 {
     napi_value result = nullptr;
diff --git a/frameworks/kits/taihe/BUILD.gn b/frameworks/kits/taihe/BUILD.gn
index f2ac4792ddca7656999f65c49afdf0a4cd94f9ef..96a1d0fe7147d7d6f08a7d318ceb812214a310e3 100644
--- a/frameworks/kits/taihe/BUILD.gn
+++ b/frameworks/kits/taihe/BUILD.gn
@@ -79,6 +79,7 @@ template("image_taihe_shared_library") {
       "src/metadata_taihe.cpp",
       "src/picture_taihe.cpp",
       "src/pixel_map_taihe.cpp",
+      "src/transfer_taihe.cpp",
       "${image_subsystem}/frameworks/innerkitsimpl/accessor/src/exif_metadata_formatter.cpp",
     ] + extra_sources
 
@@ -87,6 +88,7 @@ template("image_taihe_shared_library") {
       "${image_subsystem}/frameworks/innerkitsimpl/egl_image:egl_image",
       "${image_subsystem}/frameworks/innerkitsimpl/utils:image_utils",
       "${image_subsystem}/interfaces/innerkits:image_native",
+      "${image_subsystem}/interfaces/kits/js/common:image",
     ]
 
     external_deps = [
@@ -102,6 +104,7 @@ template("image_taihe_shared_library") {
       "hilog:libhilog",
       "hitrace:hitrace_meter",
       "ipc:rpc_ani",
+      "napi:ace_napi",
       "runtime_core:ani_helpers",
       "skia:libjpeg",
     ]
diff --git a/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe b/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe
index a98595f9a6b15ce9a374439efbd8f73421f74b02..023cd71b5c0aa2b76eb020bef067b1bd593f4f0f 100644
--- a/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe
+++ b/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe
@@ -632,6 +632,7 @@ interface Metadata {
 
 interface ImageSource {
   GetImplPtr(): i64;
+
   @gen_async("getImageInfo")
   @gen_promise("getImageInfoPromiseWithIndex")
   GetImageInfoSyncWithIndex(index: i32): ImageInfo;
@@ -738,6 +739,8 @@ interface ImageSource {
 }
 
 interface ImagePacker {
+  GetImplPtr(): i64;
+
   @gen_promise("packToData")
   PackImageSourceToDataSync(source: ImageSource, options: PackingOption): @arraybuffer Array<u8>;
 
@@ -789,6 +792,8 @@ interface Image {
 }
 
 interface ImageReceiver {
+  GetImplPtr(): i64;
+
   @get GetSize(): Size;
   @get GetCapacity(): i32;
   @get GetFormat(): ImageFormat;
@@ -834,6 +839,8 @@ interface ImageReceiver {
 }
 
 interface ImageCreator {
+  GetImplPtr(): i64;
+
   @get("capacity") GetCapacity(): i32;
   @get("format") GetFormat(): ImageFormat;
 
@@ -873,6 +880,70 @@ interface ImageCreator {
   ReleaseSync(): void;
 }
 
+// transfer functions
+function ImageSourceTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageSource;
+function ImageSourceTransferDynamicImpl(input: ImageSource): @sts_type("Any") Opaque;
+
+function ImagePackerTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImagePacker;
+function ImagePackerTransferDynamicImpl(input: ImagePacker): @sts_type("Any") Opaque;
+
+function PictureTransferStaticImpl(input: @sts_type("ESValue") Opaque): Picture;
+function PictureTransferDynamicImpl(input: Picture): @sts_type("Any") Opaque;
+
+function AuxiliaryPictureTransferStaticImpl(input: @sts_type("ESValue") Opaque): AuxiliaryPicture;
+function AuxiliaryPictureTransferDynamicImpl(input: AuxiliaryPicture): @sts_type("Any") Opaque;
+
+function ImageReceiverTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageReceiver;
+function ImageReceiverTransferDynamicImpl(input: ImageReceiver): @sts_type("Any") Opaque;
+
+function ImageCreatorTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageCreator;
+function ImageCreatorTransferDynamicImpl(input: ImageCreator): @sts_type("Any") Opaque;
+
+@!sts_inject("""
+export function imageSourceTransferStatic(input: Any): Object {
+  return imageSourceTransferStaticImpl(ESValue.wrap(input));
+}
+export function imageSourceTransferDynamic(input: Object): Any {
+  return imageSourceTransferDynamicImpl(input as ImageSource);
+}
+
+export function imagePackerTransferStatic(input: Any): Object {
+  return imagePackerTransferStaticImpl(ESValue.wrap(input));
+}
+export function imagePackerTransferDynamic(input: Object): Any {
+  return imagePackerTransferDynamicImpl(input as ImagePacker);
+}
+
+export function pictureTransferStatic(input: Any): Object {
+  return pictureTransferStaticImpl(ESValue.wrap(input));
+}
+export function pictureTransferDynamic(input: Object): Any {
+  return pictureTransferDynamicImpl(input as Picture);
+}
+
+export function auxiliaryPictureTransferStatic(input: Any): Object {
+  return auxiliaryPictureTransferStaticImpl(ESValue.wrap(input));
+}
+export function auxiliaryPictureTransferDynamic(input: Object): Any {
+  return auxiliaryPictureTransferDynamicImpl(input as AuxiliaryPicture);
+}
+
+export function imageReceiverTransferStatic(input: Any): Object {
+  return imageReceiverTransferStaticImpl(ESValue.wrap(input));
+}
+export function imageReceiverTransferDynamic(input: Object): Any {
+  return imageReceiverTransferDynamicImpl(input as ImageReceiver);
+}
+
+export function imageCreatorTransferStatic(input: Any): Object {
+  return imageCreatorTransferStaticImpl(ESValue.wrap(input));
+}
+export function imageCreatorTransferDynamic(input: Object): Any {
+  return imageCreatorTransferDynamicImpl(input as ImageCreator);
+}
+""")
+
+// global functions
 function MakeEmptySize(): Size;
 function MakeEmptyImageInfo(): ImageInfo;
 
diff --git a/frameworks/kits/taihe/include/image_creator_taihe.h b/frameworks/kits/taihe/include/image_creator_taihe.h
index fcaa3b0eeaabc205ee02e1be5e6bfa1a2aa4d278..f77e3195b31672a5eba0f1386cc40731778aeea8 100644
--- a/frameworks/kits/taihe/include/image_creator_taihe.h
+++ b/frameworks/kits/taihe/include/image_creator_taihe.h
@@ -28,14 +28,16 @@ using namespace taihe;
 using namespace ohos::multimedia::image::image;
 
 struct ImageCreatorTaiheContext;
-using CallbackResult = std::variant<std::monostate, struct Image>;
-using CompleteCallback = CallbackResult (*)(std::shared_ptr<ImageCreatorTaiheContext> &);
+using CreatorCallbackResult = std::variant<std::monostate, struct Image>;
+using CompleteCreatorCallback = CreatorCallbackResult (*)(std::shared_ptr<ImageCreatorTaiheContext> &);
 
 class ImageCreatorImpl {
 public:
     ImageCreatorImpl();
     explicit ImageCreatorImpl(std::shared_ptr<OHOS::Media::ImageCreator> imageCreator);
     ~ImageCreatorImpl();
+    int64_t GetImplPtr();
+    std::shared_ptr<OHOS::Media::ImageCreator> GetNativeImageCreator();
 
     static bool AniSendEvent(const std::function<void()> cb, std::string &name);
     static void OnProcessSendEvent(std::shared_ptr<ImageCreatorTaiheContext> &context);
@@ -60,8 +62,8 @@ private:
 };
 
 struct ImageCreatorTaiheContext {
-    CompleteCallback callBack = nullptr;
-    CallbackResult result;
+    CompleteCreatorCallback callBack = nullptr;
+    CreatorCallbackResult result;
     std::shared_ptr<uintptr_t> taiheCallback = nullptr;
     std::string name;
     ImageCreatorImpl *imageCreatorImpl_ = nullptr;
@@ -71,7 +73,7 @@ struct ImageCreatorTaiheContext {
 
 struct ImageCreatorCommonArgs {
     const std::string name;
-    CompleteCallback callBack;
+    CompleteCreatorCallback callBack;
 };
 
 class ImageCreatorReleaseListener : public OHOS::Media::SurfaceBufferReleaseListener {
diff --git a/frameworks/kits/taihe/include/image_packer_taihe.h b/frameworks/kits/taihe/include/image_packer_taihe.h
index 1bd57bcfdc1076f82f78352a8dc7e9f2f2ec529b..7a2295a0919b6c9c34f09c7eef0cc4e3f138ac64 100644
--- a/frameworks/kits/taihe/include/image_packer_taihe.h
+++ b/frameworks/kits/taihe/include/image_packer_taihe.h
@@ -30,6 +30,8 @@ public:
     ImagePackerImpl();
     explicit ImagePackerImpl(std::shared_ptr<OHOS::Media::ImagePacker> imagePacker);
     ~ImagePackerImpl();
+    int64_t GetImplPtr();
+    std::shared_ptr<OHOS::Media::ImagePacker> GetNaitveImagePacker();
 
     array<uint8_t> Packing(int32_t packType, int64_t source, PackingOption const& options, bool needReturnError);
     void PackToFile(int32_t packType, int64_t source, int32_t fd, PackingOption const& options);
diff --git a/frameworks/kits/taihe/include/image_receiver_taihe.h b/frameworks/kits/taihe/include/image_receiver_taihe.h
index 6e3b04491e3176b4232cd3c6252f60620983e7f7..26302efa3a5745300d46c80cf5d4b816824048e4 100644
--- a/frameworks/kits/taihe/include/image_receiver_taihe.h
+++ b/frameworks/kits/taihe/include/image_receiver_taihe.h
@@ -35,6 +35,8 @@ public:
     ImageReceiverImpl();
     explicit ImageReceiverImpl(std::shared_ptr<OHOS::Media::ImageReceiver> imageReceiver);
     ~ImageReceiverImpl();
+    int64_t GetImplPtr();
+    std::shared_ptr<OHOS::Media::ImageReceiver> GetNativeImageReceiver();
 
     static bool AniSendEvent(const std::function<void()> cb, std::string &name);
     static void OnProcessSendEvent(std::shared_ptr<ImageReceiverTaiheContext> &context);
diff --git a/frameworks/kits/taihe/include/image_taihe_utils.h b/frameworks/kits/taihe/include/image_taihe_utils.h
index 48a8e0bbedd5cc5bdc6f1382c77fd4c4da590e80..362470488a17833a1c23d7ee95ebe9e17940a2fb 100644
--- a/frameworks/kits/taihe/include/image_taihe_utils.h
+++ b/frameworks/kits/taihe/include/image_taihe_utils.h
@@ -18,6 +18,7 @@
 
 #include "image_source.h"
 #include "image_type.h"
+#include "napi/native_api.h"
 #include "ohos.multimedia.image.image.proj.hpp"
 #include "ohos.multimedia.image.image.impl.hpp"
 #include "taihe/runtime.hpp"
@@ -44,6 +45,7 @@ public:
     static array<string> ToTaiheArrayString(const std::vector<std::string> &src);
     static array<uint8_t> CreateTaiheArrayBuffer(uint8_t* src, size_t srcLen);
     static uintptr_t GetUndefinedPtr(ani_env *env);
+    static uintptr_t GetUndefinedPtr(napi_env env);
 
     template <typename EnumType, typename ValueType>
     static bool GetEnumKeyByValue(ValueType value, typename EnumType::key_t &key);
diff --git a/frameworks/kits/taihe/include/transfer_taihe.h b/frameworks/kits/taihe/include/transfer_taihe.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6fbaea2d14d6b626813afc88ede8906dab05fbd
--- /dev/null
+++ b/frameworks/kits/taihe/include/transfer_taihe.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H
+#define FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H
+
+#include "ohos.multimedia.image.image.proj.hpp"
+#include "ohos.multimedia.image.image.impl.hpp"
+#include "taihe/runtime.hpp"
+
+namespace ANI::Image {
+using namespace taihe;
+using namespace ohos::multimedia::image::image;
+
+ImageSource ImageSourceTransferStaticImpl(uintptr_t input);
+uintptr_t ImageSourceTransferDynamicImpl(ImageSource input);
+
+ImagePacker ImagePackerTransferStaticImpl(uintptr_t input);
+uintptr_t ImagePackerTransferDynamicImpl(ImagePacker input);
+
+Picture PictureTransferStaticImpl(uintptr_t input);
+uintptr_t PictureTransferDynamicImpl(Picture input);
+
+AuxiliaryPicture AuxiliaryPictureTransferStaticImpl(uintptr_t input);
+uintptr_t AuxiliaryPictureTransferDynamicImpl(AuxiliaryPicture input);
+
+ImageReceiver ImageReceiverTransferStaticImpl(uintptr_t input);
+uintptr_t ImageReceiverTransferDynamicImpl(ImageReceiver input);
+
+ImageCreator ImageCreatorTransferStaticImpl(uintptr_t input);
+uintptr_t ImageCreatorTransferDynamicImpl(ImageCreator input);
+} // namespace ANI::Image
+
+#endif // FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H
\ No newline at end of file
diff --git a/frameworks/kits/taihe/src/image_creator_taihe.cpp b/frameworks/kits/taihe/src/image_creator_taihe.cpp
index 2499b479633492b75515bbacad2ea8fa549e2dc3..fc7a4dba9f8be888990bc9580a7d02df9e8be427 100644
--- a/frameworks/kits/taihe/src/image_creator_taihe.cpp
+++ b/frameworks/kits/taihe/src/image_creator_taihe.cpp
@@ -49,6 +49,16 @@ ImageCreatorImpl::~ImageCreatorImpl()
     }
 }
 
+int64_t ImageCreatorImpl::GetImplPtr()
+{
+    return reinterpret_cast<uintptr_t>(this);
+}
+
+std::shared_ptr<OHOS::Media::ImageCreator> ImageCreatorImpl::GetNativeImageCreator()
+{
+    return imageCreator_;
+}
+
 int32_t ImageCreatorImpl::GetCapacity()
 {
     if (g_isCreatorTest) {
@@ -183,7 +193,7 @@ void ImageCreatorImpl::QueueImageSync(weak::Image image)
         .callBack = nullptr,
     };
 
-    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CallbackResult {
+    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CreatorCallbackResult {
         if (context->imageCreatorImpl_ == nullptr) {
             IMAGE_LOGE("imageCreatorImpl is nullptr");
             return std::monostate{};
@@ -255,7 +265,7 @@ struct Image ImageCreatorImpl::DequeueImageSync()
         .callBack = nullptr,
     };
 
-    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CallbackResult {
+    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CreatorCallbackResult {
         if (context->imageCreatorImpl_ == nullptr) {
             IMAGE_LOGE("imageCreatorImpl is nullptr");
             return std::monostate{};
@@ -312,7 +322,7 @@ void ImageCreatorImpl::OnImageRelease(::taihe::callback_view<void(uintptr_t, uin
         .callBack = nullptr,
     };
 
-    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CallbackResult {
+    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CreatorCallbackResult {
         auto native = context->imageCreatorImpl_->imageCreator_;
         if (native == nullptr) {
             IMAGE_LOGE("Native instance is nullptr");
@@ -358,7 +368,7 @@ void ImageCreatorImpl::OffImageRelease(::taihe::optional_view<::taihe::callback<
         .callBack = nullptr,
     };
 
-    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CallbackResult {
+    args.callBack = [](std::shared_ptr<ImageCreatorTaiheContext> &context) -> CreatorCallbackResult {
         if (context->imageCreatorImpl_ == nullptr || context->imageCreatorImpl_->imageCreator_ == nullptr) {
             IMAGE_LOGE("imageCreatorImpl is nullptr");
             return std::monostate{};
diff --git a/frameworks/kits/taihe/src/image_packer_taihe.cpp b/frameworks/kits/taihe/src/image_packer_taihe.cpp
index ca45a656bb6314545ec2d11e86d6aab7e9dd4dbd..324dd360be8cdbd335a342a9049278b3219256e8 100644
--- a/frameworks/kits/taihe/src/image_packer_taihe.cpp
+++ b/frameworks/kits/taihe/src/image_packer_taihe.cpp
@@ -80,6 +80,16 @@ ImagePackerImpl::~ImagePackerImpl()
     ReleaseSync();
 }
 
+int64_t ImagePackerImpl::GetImplPtr()
+{
+    return reinterpret_cast<uintptr_t>(this);
+}
+
+std::shared_ptr<OHOS::Media::ImagePacker> ImagePackerImpl::GetNaitveImagePacker()
+{
+    return nativeImagePacker_;
+}
+
 static int64_t GetDefaultBufferSize(int32_t width, int32_t height)
 {
     if (width <= SIZE_256 && height <= SIZE_256) {
diff --git a/frameworks/kits/taihe/src/image_receiver_taihe.cpp b/frameworks/kits/taihe/src/image_receiver_taihe.cpp
index 4308633dc15622844e71d67aaf5ce0664883645a..5897c88831ad3b1e703055d06e2d86509a312971 100644
--- a/frameworks/kits/taihe/src/image_receiver_taihe.cpp
+++ b/frameworks/kits/taihe/src/image_receiver_taihe.cpp
@@ -52,6 +52,16 @@ ImageReceiverImpl::~ImageReceiverImpl()
     }
 }
 
+int64_t ImageReceiverImpl::GetImplPtr()
+{
+    return reinterpret_cast<uintptr_t>(this);
+}
+
+std::shared_ptr<OHOS::Media::ImageReceiver> ImageReceiverImpl::GetNativeImageReceiver()
+{
+    return imageReceiver_;
+}
+
 void ImageReceiverImpl::UnRegisterReceiverListener()
 {
     if (imageReceiver_ != nullptr) {
diff --git a/frameworks/kits/taihe/src/image_taihe_utils.cpp b/frameworks/kits/taihe/src/image_taihe_utils.cpp
index 26c0809034685a64ea75c53194447445dcb31d07..eb93fcbc86842db1905c2e176cd90dbd7faa155c 100644
--- a/frameworks/kits/taihe/src/image_taihe_utils.cpp
+++ b/frameworks/kits/taihe/src/image_taihe_utils.cpp
@@ -140,6 +140,13 @@ uintptr_t ImageTaiheUtils::GetUndefinedPtr(ani_env *env)
     return reinterpret_cast<uintptr_t>(undefinedObj);
 }
 
+uintptr_t ImageTaiheUtils::GetUndefinedPtr(napi_env env)
+{
+    napi_value undefinedNapi = nullptr;
+    napi_get_undefined(env, &undefinedNapi);
+    return reinterpret_cast<uintptr_t>(undefinedNapi);
+}
+
 template <typename EnumType, typename ValueType>
 bool ImageTaiheUtils::GetEnumKeyByValue(ValueType value, typename EnumType::key_t &key)
 {
diff --git a/frameworks/kits/taihe/src/transfer_taihe.cpp b/frameworks/kits/taihe/src/transfer_taihe.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a92ae6cc65da2c361369ffad96e6d35aeb3d74ab
--- /dev/null
+++ b/frameworks/kits/taihe/src/transfer_taihe.cpp
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "auxiliary_picture_napi.h"
+#include "auxiliary_picture_taihe.h"
+#include "image_creator_napi.h"
+#include "image_creator_taihe.h"
+#include "image_log.h"
+#include "image_packer_napi.h"
+#include "image_packer_taihe.h"
+#include "image_receiver_napi.h"
+#include "image_receiver_taihe.h"
+#include "image_source_napi.h"
+#include "image_source_taihe.h"
+#include "interop_js/arkts_esvalue.h"
+#include "interop_js/arkts_interop_js_api.h"
+#include "picture_napi.h"
+#include "picture_taihe.h"
+#include "transfer_taihe.h"
+
+using namespace ANI::Image;
+
+namespace ANI::Image {
+
+ImageSource ImageSourceTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<ImageSourceImpl, ImageSource>();
+    }
+
+    auto imageSourceNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::ImageSourceNapi>*>(nativePtr)->lock();
+    if (imageSourceNapi == nullptr) {
+        IMAGE_LOGE("%{public}s imageSource is nullptr", __func__);
+        return make_holder<ImageSourceImpl, ImageSource>();
+    }
+    return make_holder<ImageSourceImpl, ImageSource>(imageSourceNapi->nativeImgSrc);
+}
+
+uintptr_t ImageSourceTransferDynamicImpl(ImageSource input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    ImageSourceImpl* thisPtr = reinterpret_cast<ImageSourceImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    napi_value result = OHOS::Media::ImageSourceNapi::CreateImageSourceNapi(jsEnv, thisPtr->nativeImgSrc);
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+
+ImagePacker ImagePackerTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<ImagePackerImpl, ImagePacker>();
+    }
+
+    auto imagePackerNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::ImagePackerNapi>*>(nativePtr)->lock();
+    if (imagePackerNapi == nullptr) {
+        IMAGE_LOGE("%{public}s imagePacker is nullptr", __func__);
+        return make_holder<ImagePackerImpl, ImagePacker>();
+    }
+    return make_holder<ImagePackerImpl, ImagePacker>(imagePackerNapi->GetNative(imagePackerNapi.get()));
+}
+
+uintptr_t ImagePackerTransferDynamicImpl(ImagePacker input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    ImagePackerImpl* thisPtr = reinterpret_cast<ImagePackerImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    napi_value result = OHOS::Media::ImagePackerNapi::CreateImagePackerNapi(jsEnv, thisPtr->GetNaitveImagePacker());
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+
+Picture PictureTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<PictureImpl, Picture>();
+    }
+
+    auto pictureNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::PictureNapi>*>(nativePtr)->lock();
+    if (pictureNapi == nullptr) {
+        IMAGE_LOGE("%{public}s picture is nullptr", __func__);
+        return make_holder<PictureImpl, Picture>();
+    }
+    return make_holder<PictureImpl, Picture>(pictureNapi->GetNativePicture());
+}
+
+uintptr_t PictureTransferDynamicImpl(Picture input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    PictureImpl* thisPtr = reinterpret_cast<PictureImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    std::shared_ptr<OHOS::Media::Picture> nativePicture = thisPtr->GetNativePtr();
+    napi_value result = OHOS::Media::PictureNapi::CreatePicture(jsEnv, nativePicture);
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+
+AuxiliaryPicture AuxiliaryPictureTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<AuxiliaryPictureImpl, AuxiliaryPicture>();
+    }
+
+    auto auxiliaryPictureNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::AuxiliaryPictureNapi>*>(nativePtr)->lock();
+    if (auxiliaryPictureNapi == nullptr) {
+        IMAGE_LOGE("%{public}s auxiliaryPicture is nullptr", __func__);
+        return make_holder<AuxiliaryPictureImpl, AuxiliaryPicture>();
+    }
+    return make_holder<AuxiliaryPictureImpl, AuxiliaryPicture>(auxiliaryPictureNapi->GetNativeAuxiliaryPic());
+}
+
+uintptr_t AuxiliaryPictureTransferDynamicImpl(AuxiliaryPicture input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    AuxiliaryPictureImpl* thisPtr = reinterpret_cast<AuxiliaryPictureImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    napi_value result = OHOS::Media::AuxiliaryPictureNapi::CreateAuxiliaryPicture(
+        jsEnv, thisPtr->GetNativeAuxiliaryPic());
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+
+ImageReceiver ImageReceiverTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<ImageReceiverImpl, ImageReceiver>();
+    }
+
+    auto imageReceiverNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::ImageReceiverNapi>*>(nativePtr)->lock();
+    if (imageReceiverNapi == nullptr) {
+        IMAGE_LOGE("%{public}s imageReceiver is nullptr", __func__);
+        return make_holder<ImageReceiverImpl, ImageReceiver>();
+    }
+    return make_holder<ImageReceiverImpl, ImageReceiver>(imageReceiverNapi->GetNativeImageReceiver());
+}
+
+uintptr_t ImageReceiverTransferDynamicImpl(ImageReceiver input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    ImageReceiverImpl* thisPtr = reinterpret_cast<ImageReceiverImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    napi_value result = OHOS::Media::ImageReceiverNapi::CreateImageReceiver(jsEnv, thisPtr->GetNativeImageReceiver());
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+
+ImageCreator ImageCreatorTransferStaticImpl(uintptr_t input)
+{
+    ani_object esValue = reinterpret_cast<ani_object>(input);
+    void *nativePtr = nullptr;
+    if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) {
+        IMAGE_LOGE("%{public}s unwrap esValue failed", __func__);
+        return make_holder<ImageCreatorImpl, ImageCreator>();
+    }
+
+    auto imageCreatorNapi = reinterpret_cast<std::weak_ptr<OHOS::Media::ImageCreatorNapi>*>(nativePtr)->lock();
+    if (imageCreatorNapi == nullptr) {
+        IMAGE_LOGE("%{public}s imageCreator is nullptr", __func__);
+        return make_holder<ImageCreatorImpl, ImageCreator>();
+    }
+    return make_holder<ImageCreatorImpl, ImageCreator>(imageCreatorNapi->GetNativeImageCreator());
+}
+
+uintptr_t ImageCreatorTransferDynamicImpl(ImageCreator input)
+{
+    if (input.is_error()) {
+        IMAGE_LOGE("%{public}s input is error", __func__);
+        return 0;
+    }
+    ImageCreatorImpl* thisPtr = reinterpret_cast<ImageCreatorImpl*>(input->GetImplPtr());
+    if (thisPtr == nullptr) {
+        IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__);
+        return 0;
+    }
+
+    napi_env jsEnv;
+    if (!arkts_napi_scope_open(get_env(), &jsEnv)) {
+        IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__);
+        return 0;
+    }
+    napi_value result = OHOS::Media::ImageCreatorNapi::CreateImageCreator(jsEnv, thisPtr->GetNativeImageCreator());
+    // arkts_napi_scope_close_n(jsEnv, 1, &result, nullptr);
+    return reinterpret_cast<uintptr_t>(result);
+}
+} // namespace ANI::Image
+
+TH_EXPORT_CPP_API_ImageSourceTransferStaticImpl(ImageSourceTransferStaticImpl);
+TH_EXPORT_CPP_API_ImageSourceTransferDynamicImpl(ImageSourceTransferDynamicImpl);
+TH_EXPORT_CPP_API_ImagePackerTransferStaticImpl(ImagePackerTransferStaticImpl);
+TH_EXPORT_CPP_API_ImagePackerTransferDynamicImpl(ImagePackerTransferDynamicImpl);
+TH_EXPORT_CPP_API_PictureTransferStaticImpl(PictureTransferStaticImpl);
+TH_EXPORT_CPP_API_PictureTransferDynamicImpl(PictureTransferDynamicImpl);
+TH_EXPORT_CPP_API_AuxiliaryPictureTransferStaticImpl(AuxiliaryPictureTransferStaticImpl);
+TH_EXPORT_CPP_API_AuxiliaryPictureTransferDynamicImpl(AuxiliaryPictureTransferDynamicImpl);
+TH_EXPORT_CPP_API_ImageReceiverTransferStaticImpl(ImageReceiverTransferStaticImpl);
+TH_EXPORT_CPP_API_ImageReceiverTransferDynamicImpl(ImageReceiverTransferDynamicImpl);
+TH_EXPORT_CPP_API_ImageCreatorTransferStaticImpl(ImageCreatorTransferStaticImpl);
+TH_EXPORT_CPP_API_ImageCreatorTransferDynamicImpl(ImageCreatorTransferDynamicImpl);
\ No newline at end of file
diff --git a/interfaces/kits/js/common/include/image_creator_napi.h b/interfaces/kits/js/common/include/image_creator_napi.h
index 7c39bbad6f2c144387eed1bbf8a52ba69c8e40aa..5f900493cc786371c8502496106d720d9dde5be6 100644
--- a/interfaces/kits/js/common/include/image_creator_napi.h
+++ b/interfaces/kits/js/common/include/image_creator_napi.h
@@ -51,6 +51,8 @@ public:
                            std::string name,
                            CompleteCreatorCallback callBack);
     void NativeRelease();
+    static napi_value CreateImageCreator(napi_env env, std::shared_ptr<ImageCreator> imageCreator);
+    std::shared_ptr<ImageCreator> GetNativeImageCreator();
 #ifdef IMAGE_DEBUG_FLAG
     bool isCallBackTest = false;
 #endif
diff --git a/interfaces/kits/js/common/include/image_packer_napi.h b/interfaces/kits/js/common/include/image_packer_napi.h
index 67299b785bf5d56f66da87f460efa7d638ea05a6..6c399dc93d127837d15e016a8553d688bc9cf21e 100644
--- a/interfaces/kits/js/common/include/image_packer_napi.h
+++ b/interfaces/kits/js/common/include/image_packer_napi.h
@@ -44,6 +44,7 @@ public:
     ~ImagePackerNapi();
     static napi_value Init(napi_env env, napi_value exports);
     static napi_value CreateImagePacker(napi_env env, napi_callback_info info);
+    static napi_value CreateImagePackerNapi(napi_env env, std::shared_ptr<ImagePacker> imagePacker);
     static std::shared_ptr<ImagePacker> GetNative(ImagePackerNapi* napi);
 
 private:
diff --git a/interfaces/kits/js/common/include/image_receiver_napi.h b/interfaces/kits/js/common/include/image_receiver_napi.h
index 133a88ee11c7c5c5e3e26ea0ece1b936cfc397bf..89914e3c1e6e0f870013d4357708ea447636e4e8 100644
--- a/interfaces/kits/js/common/include/image_receiver_napi.h
+++ b/interfaces/kits/js/common/include/image_receiver_napi.h
@@ -52,9 +52,12 @@ public:
                            std::string name,
                            CompleteCallback callBack);
     ImageReceiver* GetNative();
+    std::shared_ptr<ImageReceiver> GetNativeImageReceiver();
     static napi_value CreateImageReceiverJsObject(napi_env env, struct ImageReceiverCreateArgs args);
     void NativeRelease();
     void UnRegisterReceiverListener();
+
+    static napi_value CreateImageReceiver(napi_env env, std::shared_ptr<ImageReceiver> imageReceiver);
 #ifdef IMAGE_DEBUG_FLAG
     bool isCallBackTest = false;
 #endif
diff --git a/interfaces/kits/js/common/include/image_source_napi.h b/interfaces/kits/js/common/include/image_source_napi.h
index e07d227558fe0a4d449d4c0a4c4605db8a0c431d..bb0b9f6f0475367eb4627bccfa550fa0359f709d 100644
--- a/interfaces/kits/js/common/include/image_source_napi.h
+++ b/interfaces/kits/js/common/include/image_source_napi.h
@@ -46,6 +46,7 @@ public:
     static thread_local void* fileBuffer_;
     static thread_local size_t fileBufferSize_;
     static int32_t CreateImageSourceNapi(napi_env env, napi_value* result);
+    static napi_value CreateImageSourceNapi(napi_env env, std::shared_ptr<ImageSource> imageSource);
     void SetIncrementalPixelMap(std::shared_ptr<IncrementalPixelMap> incrementalPixelMap);
     void SetNativeImageSource(std::shared_ptr<ImageSource> imageSource);
     void SetImageResource(ImageResource resource);
diff --git a/interfaces/kits/js/common/include/picture_napi.h b/interfaces/kits/js/common/include/picture_napi.h
index 9d8fc2c248edf74dbc252c84d363a8dd72879ba1..a8b29a583e8339f1ba81c71a5ebf4879ea077767 100644
--- a/interfaces/kits/js/common/include/picture_napi.h
+++ b/interfaces/kits/js/common/include/picture_napi.h
@@ -33,6 +33,7 @@ public:
     static napi_value CreatePicture(napi_env env, std::shared_ptr<Picture> &picture);
     static int32_t CreatePictureNapi(napi_env env, napi_value* result);
     void SetNativePicture(std::shared_ptr<Picture> picture);
+    std::shared_ptr<Picture> GetNativePicture();
     
 private:
     static napi_value Constructor(napi_env env, napi_callback_info info);