Search

Filter

Samsung In-App Purchase 100
Sorry, no results
found for "Samsung In-App Purchase" on the website

tutorials

blog

Integrate the Samsung In-App Purchase Orders API with Your Application

samsung in-app purchase (iap) offers developers a robust solution for handling digital transactions within mobile applications available on galaxy store. whether it is selling digital goods, handling subscriptions, or managing refunds, samsung iap is designed to offer a smooth, secure experience. the samsung iap orders api expands the scope of these benefits. you can fetch all the payments and refunds history according to specified dates on your server to easily manage your application. this content guides you through the essential components for implementing both the samsung iap and samsung iap orders apis. figure 1: sample application ui in this tutorial, we provide a sample android application called book spot, which offers users the option to subscribe to their favorite books and consumable items, such as text fonts, for purchase. this user application is provided to help you to integrate samsung iap sdk with your applicaiton. finally, we also provide a sample server application to view all the payment and refund history on specific dates by calling the samsung iap orders api from the back-end server. prerequisites before implementing the samsung iap order api on your server, you need to perform iap functionalities to retrieve purchase history. you need to integrate samsung iap with your application. if you don't have an app yet, follow these steps to ensure a smooth and effective process. step 1: implement samsung iap in your app to integrate the iap system into your application, follow this general flow. integrate the samsung iap sdk into your application. initiate item purchase by calling startpayment() with the necessary parameters, such as the item id and a listener to handle the results. after the transaction, verify whether the purchase is successful with iap/v6/receipt. this involves checking if the purchase id is valid. follow the ensuring secure purchases using the samsung iap server api for more details. once the purchase is confirmed, allow the item to be consumed using consumepurchaseitems(). this step ensures that the item can be repurchased if needed. for more information about the iap sdk integration, you can follow the integration of samsung iap services in android apps article. also get help from the sample android application. step 2: upload your application upload the application for beta testing on galaxy store. a step-by-step guide with screenshots has been provided in the documentation. for more details, see the section “production closed beta test” in the test guide. step 3: purchase items finally, create products in seller portal so that users can purchase or subscribe to them while using the application. for more details about the available items that seller portal supports, see the programming guide. implementation of the samsung iap orders api the samsung iap orders api is used to view all payments and refunds on a specific date. it does this by fetching the payments and refunds history within the date you specified. let’s implement the samsung iap orders api and create a server to listen to its response. through server-to-server communication, the api returns all order data for the application. overview of the orders api to view all payments and refunds: you must make a post request to the samsung iap orders api endpoint with the required headers specified below. if you specify a date, all the payment history within this date is returned. otherwise, it only returns all the data from the day before the current date. api endpoint: https://devapi.samsungapps.com/iap/seller/orders method: post headers: add the following fields to the request header. for more information, see the create an access token page, which will help you understand how to create the access token in detail. the token is used for authorization. you can also get the service account id by clicking the assistance > api service tabs on seller portal. for more details, read the section create a service account and visit seller portal. header name description required/optional values content-type format of the request body required application/json authorization authorization security header required bearer: access_token service account id this id can be created in seller portal and is used to generate the json web token (jwt) required service-account-id parameters: the following parameters can be used to build your post request. name type required/optional description sellerseq string required your seller deeplink, which is found in your profile in seller portal and consists of a 12-digit number. packagename string optional used to view payment and refund data. you can provide the application package name. when a package name is not specified, the data for all applications is shown. requestdate string optional specify a date from which to view the payment and refund data. if the date is not specified, the data from a day before your current date is returned. continuationtoken string optional use this if you want to check if there is a continuation for the data on the next page. if there is no more data, the response is null. configuring the server you can develop a spring boot server for this purpose. here are the guidelines on how to set up this server. set up a spring boot project. for more information, follow the steps in developing your first spring boot application. set up your server endpoint. create a controller for the samsung iap orders api in an integrated development environment (ide) after importing the spring boot project you created. this helps managing all in-app order-related activities and processing them within your application. the controller receives post requests sent from samsung’s iap orders service ensuring the communication with your application. to ensure smooth communication with the samsung iap orders api, it's essential to structure your server requests effectively. below is a clear and concise breakdown of the process. 1. setup dependencies to implement rest api support, add the following okhttp library dependencies to your application's build.gradle file. implementation 'com.squareup.okhttp3:okhttp: version' implementation 'com.google.code.gson:gson: version' 2. define parameters encapsulate request parameters for cleaner handling. public class orderrequest { private final string sellerseq; public orderrequest(string sellerseq) { this.sellerseq = sellerseq; } public string tojson() { return string.format("{\"sellerseq\":\"%s\"}", sellerseq); } } 3. build the http request centralize request configuration for maintainability. public class orderservice { private static final string api_url = "https://devapi.samsungapps.com/iap/seller/orders"; private static final string token = "0djt9yzryukdogbvulxxxxxx"; private static final string service_account_id = "85412253-21b2-4d84-8ff5-xxxxxxxxxxxx"; private final okhttpclient client = new okhttpclient(); public void sendorderrequest(string sellerseq) { orderrequest orderrequest = new orderrequest(sellerseq); requestbody body = requestbody.create(orderrequest.tojson(), mediatype.parse("application/json; charset=utf-8")); request request = new request.builder() .url(api_url) .post(body) .addheader("authorization", "bearer " + token) .addheader("service-account-id", service_account_id) .addheader("content-type", "application/json") .build(); executerequest(request); } } 4. handle response ensure robust error handling for api calls. private void executerequest(request request) { client.newcall(request).enqueue(new callback() { @override public void onfailure(@notnull call call, @notnull ioexception e) { system.err.println("request failed: " + e.getmessage()); } @override public void onresponse(@notnull call call, @notnull response response) throws ioexception { try (responsebody responsebody = response.body()) { if (!response.issuccessful()) { system.err.printf("unexpected response [%d]: %s%n", response.code(), responsebody.string()); return; } system.out.println("response: " + responsebody.string()); } } }); } congratulations! you have just built the spring boot server to handle api post requests using the okhttpclient to manage http requests and responses for your sample application. example api response as previously mentioned, a json-formatted response is returned to your request. for detailed descriptions of each response body element, see the “response” section of the samsung iap orders api documentation. the following output format is a sample in which only some of the response-body data is presented. the continuationtoken parameter key returns null because there is no continuation for the data on the next page. the orderitemlist parameter key lists all the orders with specific details, such as orderid, countryid, packagename, among others. { "continuationtoken": null, "orderitemlist": [ { "orderid": "s20230210kr019xxxxx", "purchaseid": "a778b928b32ed0871958e8bcfb757e54f0bc894fa8df7dd8dbb553cxxxxxxxx", "contentid": "000005059xxx", "countryid": "usa", "packagename": "com.abc.xyz" }, { "orderid": "s20230210kr019xxxxx", "purchaseid": "90a5df78f7815623eb34f567eb0413fb0209bb04dad1367d7877edxxxxxxxx", "contentid": "000005059xxx", "countryid": "usa", "packagename": "com.abc.xyz" }, ] } usually, the responses contain all the relevant information about user purchases, such as the in-app product title, price, and payment status. therefore, you can use the information and create views for an easier order management. noteif the iap operating mode is configured to test mode, the api response is empty. this is because the api is configured to operate and return a response only in production mode. conclusion you have learned how to implement product purchase, consumption, and registration, as well as how to integrate the samsung iap orders api and configure a server to fetch all the payment and refund history within specific dates. integrating the samsung iap orders api functionality into your server is an essential step in managing your application payments history to ensure a seamless experience to users. now, you can implement the samsung iap orders api into your application to track all payments, refunds and make your business more manageable. related resources for additional information on this topic, see the resources below: android sample application source code sample server application source code add samsung in-app purchase service to your app samsung iap orders api integration of samsung iap services in android apps

Md. Hossain

https://developer.samsung.com/sdp/blog/en-us/2025/06/18/integrate-the-samsung-in-app-purchase-orders-api-with-your-application

tutorials

blog

Configuring Instant Server Notifications for Samsung IAP

in-app purchases are crucial for many applications, and the samsung in-app purchase (iap) service helps developers manage purchases, subscriptions, and refunds efficiently. to keep your server in sync with user transactions, samsung iap instant server notification (isn) sends real-time notifications to your backend server when purchase-related events occur. isn for samsung iap is a method used by samsung's system to notify your server about user activities related to in-app items and subscriptions. when a change occurs, samsung sends a notification to your server. a list of all events that trigger a notification is available here. in this article, we will build a spring boot server that handles these notifications. prerequisites to implement isn for samsung iap, it is important to focus on the requirements that helps you to most easily implement the process: create an iap public key in the seller portal. this key is used to authenticate the notifications you receive and verify that they are from the samsung iap isn system. the steps you need to follow are outlined in the create an iap public key in seller portal documentation. create an in-app item in the seller portal. follow the related documentation to create an in-app item. isn structure the isn for samsung iap service sends a notification to the application developer server. the structure of the notification is always a base64-encoded json web token (jwt) and consists of three parts. the three parts are: header payload signature header the jwt uses a jose (javascript object signing and encryption) header. similar to the envelope of a letter, the header indicates the type of notification being sent. for additional information, refer to the samsung iap isn header article. example encoded header: eyj0exaioijkv1qilcjhbgcioijsxxxxxxxx example decoded header: { "alg" : "rs256", "typ" : "jwt" } payload the payload is the actual content of the message, like the letter inside the envelope. this part contains the crucial information you need, like the user’s subscription details, the product they have subscribed to, and the current status of the subscription. more details about the payload check are available in the following documentation and data claims section. example encoded payload: eyjpc3mioijpyxauc2ftc3vuz2fwchmuy29tiiwic3viijoirvzftlrftkfnrsisimf1zci6wyjjb20ucgfja2fnzs5uyw1lil0sim5izii6mtcxnziwncwiawf0ijoxnze3mja0lcjkyxrhijp7innlbgxlck5hbwuiom51bgwsim nvbnrlbnroyw1lijoitwfydgluzsj9lcj2zxjzaw9uijoxxxxxxxx example decoded payload: { "iss": "iap.samsungapps.com", "sub": "event_name", "aud": ["com.package.name"], "nbf": 1717xxxxxx, "iat": 1717xxxxxx, "data": {..}, "version": "x.0" } signature the signature is the security feature that acts as a digital stamp to prove the message is genuine and hasn’t been tampered with. you can use this signature to verify that the data in the payload is authentic and was created by samsung. further information is provided in the signature documentation. now that we know the structure of the isn for samsung iap, we can configure the server to handle it. server configuration according to the isn for samsung iap requirements, you must set up a server to receive the notifications. below, we create a spring boot server. use your preferred ide (integrated development environment) or online spring initializr to create a spring boot server. follow the steps below to set up your own server. step 1: set up a spring boot project use the spring initializr tool to create a new project. choose the following dependency: spring web generate and download the project. step 2: import the project into ide open the project in the ide (intellij, eclipse, etc.) step 3: set up isn endpoint create a controller for isn notifications in the ide after importing the spring boot project. the controller receives post requests (subscription, refund and cancel) sent from samsung’s iap server. add necessary dependencies in the build.gradle file: { implementation 'com.auth0:java-jwt:4.0.0' //for jwt verifier implementation 'org.json:json:20230227' // for json parsing } load the public key detailed in the prerequisite section: private string loadpublickey(string filename) throws ioexception { classpathresource resource = new classpathresource(filename); stringbuilder contentbuilder = new stringbuilder(); try (inputstream inputstream = resource.getinputstream(); bufferedreader reader = new bufferedreader(new inputstreamreader(inputstream))) { string line; while ((line = reader.readline()) != null) { contentbuilder.append(line).append("\n"); } } return contentbuilder.tostring(); } remove headers, footers, and whitespace from the public key and convert it to the rsapublickey format. private rsapublickey getrsapublickeyfrompem(string pem) throws exception { string publickeypem = pem .replace("-----begin public key-----", "") .replace("-----end public key-----", "") .replaceall("\\s", ""); // remove headers, footers, and whitespace byte[] encoded = base64.getdecoder().decode(publickeypem); keyfactory keyfactory = keyfactory.getinstance("rsa"); x509encodedkeyspec keyspec = new x509encodedkeyspec(encoded); return (rsapublickey) keyfactory.generatepublic(keyspec); } create a jwt verifier with rsapublickey and, finally, verify the jwt. if the verification is successful, decode the jwt to retrieve the decoded json payload. the decoded payload contains the message of the notification. private void verifytoken(string token, rsapublickey publickey) { try { // create jwt verifier with rsa public key algorithm algorithm = algorithm.rsa256(publickey, null); // verify the jwt token jwtverifier verifier = jwt.require(algorithm) .withissuer("iap.samsungapps.com") .build(); decodedjwt jwt = verifier.verify(token); // decode the jwt token string payloadjson = new string(base64.getdecoder().decode(jwt.getpayload())); jsonobject jsonobject = new jsonobject(payloadjson); //print decoded json payload system.out.println("payload as json: " + jsonobject.tostring(4)); } catch (jwtverificationexception e) { system.out.println("invalid token: " + e.getmessage()); } } in this sample project, we have only printed the payload data to the console. you can use this according to your requirements. step 4: deploy the server the server needs a publicly accessible url to receive isn notifications. in our project, we have used codesandbox to get the publicly accessible url for the server. once you deploy the project on codesandbox, you will get a publicly accessible url that looks like this: https://abcde-8080.csb.app/iap/isn. testing with seller portal test your server with samsung galaxy store seller portal: set the codesandbox url as the isn url in seller portal. go to the in-app purchase section and create items with the required details. in the "isn url" field, set the publicly accessible server url. after setting the url, click the test button. a notification will be sent to the specified server immediately. you will also receive a notification on the server that you just deployed in the codesandbox. figure 1: testing with seller portal testing with a sample application now it is time to test the isn for samsung iap from the user application. further details are provided in the integrate the samsung in-app purchase orders api with your application article. download the sample application from this blog and then follow the instructions until you reach the "implementation of item subscription" section. in the sample application, after clicking the "buy" button, startpayment() is called. the onpayment() callback returns an indication of whether the purchase succeeds or fails. if the purchase is successful, the iap server sends a notification to your server. iaphelper.startpayment(itemid, string.valueof(1), new onpaymentlistener() { @override public void onpayment(@nonnull errorvo errorvo, @nullable purchasevo purchasevo) { if (purchasevo != null) { log.d("purchaseid" , purchasevo.getpurchaseid().tostring()); // purchase successfull }else { log.d("purchaseerror" , errorvo.tostring()); } } }); example response after successfully purchasing an item, a json response is returned. for more information on each parameter, you can check the item purchased documentation. example json response: "data" : { "itemid": "example_item_id", "orderid": "xxxx40601kra00xxxxx", "purchaseid": "xxxxx7245d57cc1ba072b81d06e6f86cd49d3da63854538eea689273787xxxxx", "testpayyn": "n", "betatestyn": "n", "passthroughparam": null } notefor different event types, it sends different data claims. for more detailed information regarding data claims, see data claims. conclusion by implementing the isn for samsung iap with your server, you can easily and securely stay in sync with user in-app purchases. integrating isn for samsung iap helps you improve your application management experience and grow your application’s revenue. following this guide will help you smoothly set up the system and provide a better way to manage your application. references for additional information on this topic, see the resources below: download the sample spring boot server samsung iap instant server notification documentation integrate the samsung in-app purchase orders api with your application

Md. Hossain

https://developer.samsung.com/sdp/blog/en-us/2025/03/25/configuring-instant-server-notifications-for-samsung-iap

Develop Samsung IAP

web

Samsung In-App Purchase | Samsung Developers

samsung in-app purchase seamless integration with galaxy store for your in-app purchase products what is samsung in-app purchase? samsung in-app purchase (iap) is a payment service that makes it possible to sell a variety of products in applications for samsung galaxy store and internally manages communication with supporting iap services in the samsung ecosystem, such as samsung account, samsung checkout, and samsung rewards. learn more four basic steps to selling in-app products start selling in-app products by integrating with samsung iap. 1. develop your app using our sdk download the samsung in-app purchase sdk and integrate it into your app. 2. request commercial seller status you must be a commercial seller in order to sell your in-app products. 3. register your app upload your binary file to samsung galaxy store seller portal. 4. add in-app products to your app add in-app products and register product-related information. technical documents programming guide how to integrate and configure iap, the iap sdk and iap server apis, and what to do before submitting your app to galaxy store. subscription guide how to manage subscriptions and an explanation of the pricing options configured in samsung galaxy store seller portal. test guide how to test in-app product purchase and payment. iap api guides how to view, register, modify, and remove samsung iap products and view all payments and refunds on a specific date. sdk and plugins sdk samsung iap libraries and sample app. unity plugin samsung iap-related scripts and libraries used to integrate with the unity engine. unreal plugin samsung iap-related scripts and libraries used to integrate with the unreal engine. videos samsung developers youtube nov 6, 2019 maximize your revenue with samsung in-app purchase learn about the new features and improvements released in samsung iap 6.0. review the steps to register your app in seller portal, test samsung iap integration, and how to publish your app in galaxy store. nov 6, 2019 nov 11, 2018 monetize your games with samsung in-app purchase introduction to samsung iap plug-in functionality for unity and unreal game engines. learn how to integrate, register and publish your game with samsung iap. nov 11, 2018 have questions? samsung answers your frequently asked questions and provides a forum to communicate with other developers. faq forum

https://developer.samsung.com/iap/

Learn Code Lab

codelab

Add Samsung In-App Purchase service to your app

add samsung in-app purchase service to your app objective learn how to integrate samsung in-app purchase iap service into your app so that users can purchase digital consumable and non-consumable items within the app registered in the galaxy store overview the samsung in-app purchase iap service offers developers a robust solution for handling digital purchases within mobile apps it ensures a smooth and secure experience when purchasing digital goods or items, managing subscriptions, or dealing with refunds and consumed items the iap sdk makes integrating the iap functionality into your app simple, allowing you to configure iap settings, retrieve item details, offer and sell items, and manage purchased items effortlessly to successfully sell in-app items, follow these four basic steps download and integrate the samsung iap sdk into your application request for commercial seller status in the samsung galaxy store seller portal upload your application’s binary file in the seller portal add in-app items to your app in-app items can be categorized into three types consumable, non-consumable, and subscription consumable these items can be used only once and can be repurchased multiple times by the app user non-consumable non-consumable items can be used any number of times and cannot be repurchased subscription with subscription items, app users can access them any number of times throughout the duration of their subscription for more information, go to samsung iap set up your environment you will need the following android studio latest version recommended samsung iap sdk latest version samsung galaxy device android 6 0 or higher samsung galaxy store seller portal commercial seller account sample code here is a sample code for you to start coding in this code lab download it and start your learning experience! in-app purchase turbobike sample code 1 3 mb start your project in android studio, click open to open an existing project locate the downloaded android project turbobike_blank_code from the directory and click ok register the app and its items in the seller portal to register the sample app along with the in-app items in the samsung galaxy store seller portal, follow these steps sign in using your commercial seller account in android studio, modify the package name of the sample app navigate to app > kotlin + java > com example turbobike view, and in the mainactivity java file, refactor the application name turbobike from the package name com example turbobike for all directories notethe package name com example turbobike is already registered in the seller portal to avoid any conflicts, rename it with a different package name build the apk from android studio and upload the binary to the seller portal once the testing process is complete and the app functions smoothly as intended, return to this step and upload the final apk file under the in app purchase tab, add three items named bike, booster, and fuel these are item ids of the in-app items created in the sample app where the bike is a non-consumable item, while both booster and fuel are consumable items when adding the bike item, uncheck this item can be purchased multiple times checkbox refer to the step-by-step guide for detailed instructions lastly, add a licensed tester to enable purchasing within the app edit your seller portal profile and include your samsung account in the license test field on the test device, sign in with the same samsung account initialize the samsung iap sdk before using the samsung iap sdk library, certain configurations are necessary, which are already applied in the sample code provided the samsung-iap-6 3 0 aar library is added to the app > libs folder, and included as a dependency in the module-level build gradle file dependencies { … implementation filetree dir 'libs', include ['* aar'] } these necessary permissions are already added in the androidmanifest xml file com samsung android iap permission billing to connect to iap and enable in-app item registration in seller portal android permission internet because iap uses the internet <uses-permission android name="com samsung android iap permission billing" /> <uses-permission android name="android permission internet" /> go to mainactivity java and in the oncreate function, create an instance of the samsung iap sdk to utilize the functionalities it offers set the operating mode to operation_mode_test to purchase items without payment and enable only licensed testers to test without incurring charges iaphelper = iaphelper getinstance getapplicationcontext ; iaphelper setoperationmode helperdefine operationmode operation_mode_test ; notebefore submitting the app for beta testing or release, change the operating mode to operation_mode_production get the list of all items owned by the user the getownedlist function returns a list of items that the user has previously purchased, including consumable items that have not been reported as consumed non-consumable items subscription items that are in free trial and active state call the getownedlist function from the iaphelper class also, check if there are any consumable items in the returned list and call the handleconsumableitems function with the purchase id of each consumable item iaphelper getownedlist iaphelper product_type_all, new ongetownedlistlistener { @override public void ongetownedproducts @nonnull errorvo errorvo, @nonnull arraylist<ownedproductvo> arraylist { if errorvo geterrorcode == iaphelper iap_error_none { for ownedproductvo item arraylist { if item getisconsumable { // consume the purchased item handleconsumableitems item getpurchaseid ; } } } else { log d "getownedproducts failed ", errorvo tostring ; } } } ; notecall getownedlist whenever launching the application to check for unconsumed items or subscription availability report consumable items as consumed mark the consumable items returned from getownedlist and those successfully purchased with startpayment as consumed by calling the consumepurchaseditems function iaphelper consumepurchaseditems itemid, new onconsumepurchaseditemslistener { @override public void onconsumepurchaseditems @nonnull errorvo errorvo, @nonnull arraylist<consumevo> arraylist { if errorvo geterrorcode == iaphelper iap_error_none { toast maketext getapplicationcontext ,"consumed successfully now you can purchase another item ", toast length_short show ; } else { toast maketext getapplicationcontext , "consume failed " + errorvo geterrorstring , toast length_short show ; } } } ; this makes the items available for repurchase, regardless of whether they are used or not in the sample app, consumable items cannot be used and it only stores the total count of the items purchased get item details to retrieve information about some or all in-app items registered to the app, use the getproductsdetails function by specifying an item id such as bike or booster, you can fetch details for a particular in-app item to obtain information about all in-app items available in the seller portal for the user, pass an empty string "" as the argument iaphelper getproductsdetails "bike, booster, fuel", new ongetproductsdetailslistener { @override public void ongetproducts @nonnull errorvo errorvo, @nonnull arraylist<productvo> arraylist { if errorvo geterrorcode == iaphelper iap_error_none { for productvo item arraylist { if item getitemid equals itemid { // set product details value to ui product settext "product name " + item getitemname ; price settext "product price " + item getitempricestring ; currency settext "currency " + item getcurrencycode ; // click continue button to purchase dialogbutton setonclicklistener dialogbtnlistener ; } } } else { toast maketext getapplicationcontext , "getproductdetails failed " + errorvo geterrorstring , toast length_short show ; } } } ; handle item purchase and payment process to initiate a purchase and complete the payment transaction process, use the startpayment function the result of the purchase is specified in the onpaymentlistener interface, which includes the detailed purchase information purchasevo in case of a successful transaction if there's an error during the payment process, an error code -1003 indicates that the non-consumable item is already purchased for further information on error responses, refer to the documentation on response codes iaphelper startpayment itemid, string valueof 1 , new onpaymentlistener { @override public void onpayment @nonnull errorvo errorvo, @nullable purchasevo purchasevo { if errorvo geterrorcode == iaphelper iap_error_none { log d "purchaseid " , purchasevo getpurchaseid ; // non-consumable item, can purchase single time if itemid equals "bike" { purchasebikebtn settext "already purchased" ; } // consumable item, can purchase multiple time else if itemid equals "booster" { handleconsumableitems purchasevo getpurchaseid ; // update booster count in ui boostercount+=1; boostercountertv settext "⚡ "+boostercount+" ev" ; }else if itemid equals "fuel" { handleconsumableitems purchasevo getpurchaseid ; // update fuel count in ui fuelcount+=1; fuelcountertv settext "⛽ "+ fuelcount+" ltr" ; } }else { // non-consumable item, already purchase if errorvo geterrorcode == -1003 { purchasebikebtn settext "already purchased" ; } } } } ; upon successfully purchasing a consumable item, the consumepurchaseditems function is called through the handleconsumableitems function the total number of purchased boosters and fuel is displayed on the app ui using the boostercountertv settext and fuelcountertv settext methods respectively run the app after building the apk, install the app on a samsung galaxy device test the app by making purchases the turbo bike can only be bought once, while either the booster or fuel can be purchased multiple times after purchasing in-app items, the app shows that the bike has already been purchased along with the number of boosters and fuel bought you're done congratulations! you have successfully achieved the goal of this code lab now, you can integrate samsung iap sdk into your application by yourself! if you are having trouble, you may download this file in-app purchase turbobike complete code 1 3 mb to learn more about developing apps with samsung iap sdk, visit developer samsung com/iap

https://developer.samsung.com/codelab/iap/in-app-purchase.html

product_updates game, mobile, marketplace

news

Updated Unity Plugin for Samsung In-App Purchase

do you build mobile games with the unity development platform? the samsung in-app purchase (iap) unity plugin now supports samsung iap version 6.1.

https://developer.samsung.com/sdp/news/en-us/2020/06/24/updated-unity-plugin-for-samsung-in-app-purchase

tutorials game, mobile, marketplace

blog

Using the Samsung In-App Purchase SDK in your Unity Games

in this article, you will learn how to integrate the samsung in-app purchase (iap) sdk in your unity games. you can also follow along on youtube. unity plugin for samsung iap in order to use the samsung iap sdk in your unity game, follow these steps: download the unity plugin for samsung iap install the plugin. in unity, click assets -> import package -> custom package drag the script onto a game object. this can be any ui object, or as seen in the video, a character from your game. once you have included the script, review the documentation to see in detail how to call the sdk from your game code. here are the basics: operation mode in order for galaxy store to know if your game is in testing or production mode, you must use the setoperationmode method. samsungiap.instance.setoperationmode(operationmode.operation_mode_test); the possible values for the parameter are operationmode.operation_mode_test, operationmode.operation_mode_test_failure, and operationmode.operation_mode_production. request information about the items available for sale to find out what items can be offered from the game, you must invoke the getproductsdetails method. samsungiap.instance.getproductsdetails("com.mygame.product1, com.mygame.product2,com.mygame.product3", ongetproductsdetails); in this example, the information for products 1, 2, and 3 is being requested, since the identifiers of those products are being sent, separated by commas. samsungiap.instance.getproductsdetails("", ongetproductsdetails); in this example, the information of all available products is being requested, since no product identifier is being sent. start a payment in order to start the purchase of a product, the startpayment method must be invoked. samsungiap.instance.startpayment("com.mygame.product1", "pass_through_value", onpayment); this example is starting the transaction for "com.mygame.product1". you can specify the value of the second parameter and use it to verify the success of the purchase. and finally, the callback is specified, which is the method that will be invoked when the transaction is completed, regardless of whether it was successful or not. consumable items you can use the consumepurchaseditems method to replenish consumable products. for example,the player could buy energy in your game as many times as he wants. the first parameter is the identifier of the purchase of the item. samsungiap.instance.consumepurchaseditems(purchase_id, onconsume); and the second parameter is the onconsume method that fires when the process has finished, and this contains information about the consumed item and the processing of api calls. query previously purchased items to get the list of all the products that a player has bought, you can use the getownedlist method. samsungiap.instance.getownedlist(itemtype.all, ongetownedlist); the first parameter can be itemtype.all, itemtype.item, or itemtype.subscription. with itemtype.all the method returns all non-consumable items previously purchased, consumable items that have not been consumed, and subscription items with active subscriptions. with itemtype.item the method returns all non-consumable items purchased and consumable items that have not been consumed. and finally, with itemtype.subscription the method returns all subscription items purchased with active subscriptions. the second parameter is the method that will be triggered when the process has finished. list your app and items for sale in galaxy store the process for selling your game in galaxy store, when it includes payments and microtransactions through the samsung iap sdk, is as follows: 1. seller portal registration to create your account and publish in galaxy store, go to http://seller.samsungapps.com click on the top corner to create your account. if you already have a samsung account, sign in with it. 2. request commercial status once you have created your account on the seller portal, request commerical seller status by clicking the button indicated in the image. this is necessary to be able to sell different items from your application. 3. app registration to see all the details of how to register your application in the seller portal, watch this video. you will be prompted to enter your game information, such as the name, description, and promotional images. 4. register in-app items when your account has been approved as a commerical seller account, you will be able to access the “in-app purchase” section. here you can register the different items you are going to sell, such as unlimited lives, special powers, or customization options for the characters in your game. in the video, you can see a little more detail on how to register each of the items. learn more about creating games with samsung and reaching its global audience: https://developer.samsung.com/galaxy-games you can connect with diego, a sr. developer evangelist, on twitter. have questions? post them in our forums.

Diego Lizarazo Rivera

https://developer.samsung.com/sdp/blog/en-us/2020/08/18/using-the-samsung-in-app-purchase-sdk-in-your-unity-games

webinar game, mobile

events

Using the Samsung In-App Purchase SDK in your Unity Games

continuing our webinar series for game developers, join this samsung developer program online talk and learn how to integrate the samsung in-app purchase (iap) sdk in your unity games. the galaxy store is a premium store to make galaxy phones come alive in their own, unique way. discover how to use samsung’s payment service that makes it possible to sell a variety of items in applications for the galaxy store. at the end of this talk you will have the knowledge to modify your unity games and have a new way to monetize them, whether it is with one-off payments or subscriptions. additionally, we will check the samsung iap unity plugin’s methods and functionalities, facilitating a rapid integration with your existing games.

https://developer.samsung.com/sdp/events/en-us/2020/07/30/using-the-samsung-in-app-purchase-sdk-in-your-unity-games

tutorials game, mobile

blog

Cómo Usar el Samsung In-App Purchase SDK en sus Juegos Creados con Unity

en este video del programa para desarrolladores de samsung, aprenda cómo integrar el sdk de compras en la aplicación (iap) de samsung en sus juegos de unity. puede obtener más información en https://developer.samsung.com/iap el proceso general para publicar su juego, cuando incluye pagos y microtransacciones por medio del samsung iap sdk es el siguiente: 1- registro en el portal para crear su cuenta y publicar en la galaxy store puede ir a http://seller.samsungapps.com haga clic en la esquina superior para crear su cuenta. si ya tiene una cuenta de samsung, puede ingresar con ella. 2- solicitar el status de vendedor una vez que haya creado su cuenta en el portal de desarrollo, puede solicitar su estatus de vendedor haciendo clic en el botón indicado en la imagen. esto es necesario para poder vender diferentes artículos desde su aplicación. 3- registrar su aplicación/juego para ver todo el detalle de cómo registrar su aplicación en el portal de ventas, puede ver el video que se encuentra en https://youtu.be/fil7dmd1v3g en general, se le va a solicitar que ingrese la información de su juego, como el nombre, descripción e imágenes promocionales. 4- registro de los artículos en venta cuando su cuenta ha sido aprobada como una cuenta de vendedores, podrá tener acceso a la sección de “in app purchase”. aquí podrá registrar los diferentes artículos que va a vender, como vidas ilimitadas, poderes especiales, u opciones de personalización para los personajes de su juego. en el video podrá ver un poco más de detalle de cómo registrar cada uno de los artículos. plugin para unity para poder usar el kit de desarrollo de la samsung iap, debe seguir los siguientes pasos: 1- descargar desde https://developer.samsung.com/iap/samsung-iap-unity-plugin.html 2- instalar el plugin a. en unity haga clic en assets -> import package -> custom package 3- arrastrar el script en un objeto del juego a. este puede ser cualquier objeto de la ui, o como se ve en el video, un personaje de su juego. una vez que haya incluido el script, puede revisar la documentación (https://developer.samsung.com/iap/samsung-iap-unity-plugin.html) para ver en detalle cómo llamar la sdk desde el código de su juego, pero aquí tiene los conceptos básicos: modo de operación para que la galaxy store sepa si su juego está realizando pruebas, o si ya està en modo de producción, debe usar el método setoperationmode. samsungiap.instance.setoperationmode(operationmode.operation_mode_test); los posibles valores para el parámetro son operationmode.operation_mode_test, operationmode.operation_mode_test_failure, y operationmode.operation_mode_production. solicitar información de los artículos disponibles en venta para saber qué artículos se pueden ofrecer desde el juego, debe invocar el método getproductdetails. samsungiap.instance.getproductdetails("com.mygame.product1, com.mygame.product2,com.mygame.product3", ongetproductsdetails); en este ejemplo se está solicitando la información de los productos 1, 2, y 3, ya que se está enviando los identificadores de esos productos, separados por comas. samsungiap.instance.getproductdetails("", ongetproductsdetails); en este ejemplo se esta pidiendo la información de todos los productos disponibles, ya que no se está enviando ningún identificador de productos. iniciar un pago para poder empezar la compra de un producto se debe invocar el método startpayment. samsungiap.instance.startpayment("com.mygame.product1", "pass_through_value", onpayment); en este ejemplo se está iniciando la transacción para el “com.mygame.product1”. usted puede especificar el valor del segundo parámetro y utilizarlo para verificar el éxito de la compra. y por último se especifica el “callback”, que es el método que se va a invocar cuando se finalice la transacción, sin importar si esta fue exitosa o no. artículos consumibles usted puede usar el método consumepurchaseditems para reaprovisionar productos consumibles. así el jugador puede comprar energía en su juego cuantas veces quiera, por ejemplo. el primer parámetro es el identificador de la compra del artículo. samsungiap.instance.consumepurchaseditems(purchase_id, onconsume); y el segundo parámetro es el método onconsume que se activa cuando el proceso ha terminado, y este contiene información sobre el artículo consumido y el procesamiento de llamadas a la api. consultar productos adquiridos anteriormente para obtener la lista de todos los productos que un jugador ha comprado, puede usar el método getownedlist. samsungiap.instance.getownedlist(itemtype.all, ongetownedlist); el primer parámetro puede ser itemtype.all, itemtype.item, o itemtype.subscription. con itemtype.all el método devuelve todos los artículos no consumibles comprados, los artículos consumibles que no se han consumido y los artículos de suscripción con suscripciones activas. con itemtype.item el método devuelve todos los artículos no consumibles comprados y los artículos consumibles que no se han consumido. y por último, con itemtype.subscription el método devuelve todos los artículos de suscripción comprados con suscripciones activas. el segundo parámetro, es el método que se activará cuando el proceso ha finalizado. para obtener más tutoriales, visite samsung developers. (http://developer.samsung.com/)

Diego Lizarazo Rivera

https://developer.samsung.com/sdp/blog/en-us/2020/09/16/cmo-usar-el-samsung-in-app-purchase-sdk-en-sus-juegos-creados-con-unity

product_updates mobile, game

news

Samsung IAP SDK v6.1.1 is Available for Download

download the latest samsung in-app purchase (iap) sdk and start selling in-app items from your app in galaxy store. samsung in-app purchase sdk v6.1.1 (7 mb) 3/15/2024 samsung iap sdk v6.1.1 includes enhancements for payment security, distributes the aar library instead of the project file, and updates the minsdkversion and targetsdkversion. use the plugins to integrate with unity and unreal engines. see samsung in-app purchase for more information about using the sdk.

https://developer.samsung.com/sdp/news/en-us/2024/04/10/samsung-iap-sdk-v611-is-available-for-download

Develop Samsung IAP

doc

SDK & Sample

sdk and sample samsung in-app purchase sdk v6 4 0 6 9 mb 04/09/2025 noteif your app is integrated with samsung iap sdk 6 0 or earlier with target api level 30 android r or higher, an android policy change requires an update to the manifest file without this update, android r or higher users may not be able to make a payment to the manifest file, add the following <queries> <package android name="com sec android app samsungapps" /> </queries> if you are using samsung iap sdk 6 1 or higher, you do not need to make this update release note april 9, 2025 release version samsung in-app purchase sdk v6 4 0 release contents contents descriptions sdk libraries provides iap sdk sample provides iap sample applications change history samsung in-app purchase 6 4 0 2025 04 09 released in in-app purchase 6 4 0 new acknowledgepurchases for acknowledging that the user has been granted entitlement for purchased non-consumable items and subscriptions acknowledgedstatus is delivered in response to getownedlist minorstatus is delivered in response to startpayment passthroughparam has been deprecated in startpayment , changesubscriptionplan samsung in-app purchase 6 3 0 2024 10 24 released in in-app purchase 6 3 0 new changesubscriptionplan for changing existing subscription to another tier of the same subscription subscriptionpricechangevo delivered in response to getownedlist when the subscription price is changed warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v6 3 0 6 7 mb 10/24/2024 samsung in-app purchase 6 2 0 2024 07 12 released in in-app purchase 6 2 0 new getpromotioneligibiilty for user-specific subscription promotion inquiry warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v6 2 0 7 mb 7/12/2024 samsung in-app purchase 6 1 1 2024 03 15 released in in-app purchase 6 1 1 new distributing the aar library rather than the project file set minsdkversion to 23 and targetsdkversion to 34 enhanced enhancement of payment security warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v6 1 1 7 mb 3/15/2024 samsung in-app purchase 6 1 2020 10 14 released in in-app purchase 6 1 new apply one ui 2 concept enhanced refactoring error codes remove an error pop-up in case of network errors modification according to change of package visibility policy in android 11 deprecated _showsuccessdialog parameter in startpayment api warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v6 1 785kb 10/14/2020 samsung in-app purchase 6 0 2019 12 12 released in in-app purchase 6 0 new lower and regular tiered subscription pricing feature subscription test feature subscription availability period feature and seller portal setting samsung checkout ui / ux subscription sales data available at seller portal > statistics getorderid api in the purchasevo object of the startpayment method response restful /iap/v6/receipt api for receipt verification enhanced email receipt formats getsubscriptionstatus api deprecated getpurchasereceipt api warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v6 0 425kb 12/12/2019 samsung in-app purchase 5 1 0 2018 05 24 released with enhanced stability and better performance warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v5 1 0 408kb 05/24/2018 samsung in-app purchase 5 0 1 2017 12 07 fixed a bug arising from android oreo policy changes sample application has been modified warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v5 0 1 396kb 12/07/2017 samsung in-app purchase 5 0 0 2017 11 09 the four existing, complex product types consumable, non-consumable, non-recurring subscription nrs , and auto-recurring subscription have been simplified into two types item and subscription version 5 0 provides a new api set and does not support the api set from previous versions the new api set has the following major characteristics supports managed products as of version 5 0, the iap system manages the history of owned consumable items with this information, the iap system can prevent products from being repurchased before purchase is completed and guarantees product provision in case of an unexpected event, such as a network or battery problem owned product list this function is used to provide lists of current unconsumed items and available subscriptions, not a purchase history upon launching an application, this function calls getownedlist if lists of unconsumed items exist, they must be released using the consumepurchaseditems function product details this function provides not only a list of all products, but also a list of requested products pass-through parameter this is a type of transaction id that a developer creates and sends when there is a payment request, which responds with the same value for the processed iap payment result and is used to enhance security warningthis is an older version of the samsung in-app purchase sdk we recommend using the most recent version samsung in-app purchase sdk v5 0 0 429kb 11/09/2017 samsung in-app purchase 4 0 0 2016 09 08 issue details there is a runtime exception when samsung billing 4 0 is not updated in user device solutions for this issue use new iap4helper in samsung in-app purchase 4 0 1 file samsung in-app purchase 3 0 1 2016 01 15 issue details when your application's targetsdkversion in android manifest xml is set to 23, the application always crashes refer to https //code google com/p/android-developer-preview/issues/detail?id=2353 solutions for this issue choose between 1 and 2 below modify the source code of iap3helper that already exists comment out or delete lines for windownodisplay in styles xml path \samples\iap3helper\src\main\res\values\styles xml show lines <style name="theme empty" parent="apptheme"> <item name="android windowbackground">@android color/transparent</item> <item name="android colorbackgroundcachehint">@null</item> <item name="android windowistranslucent">true</item> <item name="android windowanimationstyle">@null</item> <item name="android windownotitle">true</item> <item name="android windowcontentoverlay">@null</item> <item name="android backgrounddimenabled">true</item> <item name="android windowdisablepreview">true</item> <!--<item name="android windownodisplay">true</item>--> </style> use the new iap3helper in the samsung in-app purchase 3 0 1 sdk samsung in-app purchase 3 0 0 2015 05 21 in-app purchase 3 0 supports auto-recurring subscriptions to let app developers sell in-app products every month with automated and recurring billing itemgroupid is replaced by package name of 3rd party application as a result, itemgroupid is deprecated in-app purchase 3 0 supports the use of custom product ids like "gun", "machinegun", "bullet", and so on new method to get cached inbox list is added this method gets the purchased product list just for specified product product ids especially, this new method gets fast response because client caching is supported samsung in-app purchase 2 0 1 2014 12 31 fixed a bug rising from android 5 0 policy changes samsung in-app purchase library has been modified to fix abruptly shut down of apps using samsung in-app purchase enhancements to developer guide 2014 01 07 the iap 2 0 library and iap 2 0 programming guide, the libraries and programming guides for adobe air developers, as well as the sample source have been updated samsung in-app purchase 2 0 2013 06 20 in-app purchase 2 0 supports two product types items [consumable, non-consumable] and subscriptions to provide greater convenience for app development previous imei-based product purchase history management is replaced by account-based management non-consumable items purchased while signed in using a user account can be recovered after app reinstallation if the account’s purchase history can be confirmed supports single sign-on, which allows users to access all content services supported by samsung after signing in with their samsung account within in-app purchase in-app purchase v2 0 now supports sales of products in the united states, which is the world’s largest market us users can purchase products using a credit card within apps that utilize in-app purchase 2 0 in-app purchase 2 0 features the ux of the latest version of samsung apps, offering a better ux user experience the previous library is switched to a stand-alone-type apk, providing easier synchronizing between apps and in-app purchase samsung in-app purchase 1 95 0 2013 02 15 in korea, you are required to enter your resident registration number when making a small purchase through your phone according to act on promotion of utilization of information and communications network, the collector of resident registration numbers has changed from samsung to pg after february 18th, it is impossible to make in-app purchases in korea using sdk v1 90 0 or lower if you develop applications with this updated sdk, however, you can sell in-app products in korea as before samsung in-app purchase 1 90 0 2012 12 18 you can apply in-app purchase to applications developed in unity 3d game engine user interface has been dramatically improved user interface has been dramatically improved you can see subdivided error codes and user-friendly error messages samsung in-app purchase 1 80 0 ~2012 06 29 2012 06 29 samsung in-app purchase 1 80 0 2012 05 07 samsung in-app purchase 1 77 0 2012 01 20 samsung in-app purchase 1 60 0 2011 10 27 samsung in-app purchase 1 50 0 features overall samsung account log-in functionality various payment methods across countries in the world payment test without charge beta test environment product consumption management enhanced security with pass-through parameter flexible free trial period and multiple subscription payment cycles product types item subscription

https://developer.samsung.com/iap/release-note.html

Didn’t find what you were looking for?

FAQ

Search frequently asked
questions
by keywords.

Join the Forum

Visit the Forum to ask
questions and exchange
ideas with other developers.

Get Support

Submit a 1:1 Support request
and receive a response
within 2 business days.

Preferences Submitted

You have successfully updated your cookie preferences.