Filter

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

tutorials

blog

Samsung IAP Publish API Web Integration

introduction the samsung iap publish api enables developers to efficiently manage in-app purchase (iap) products within applications. this api serves as the foundation for handling crud (create, read, update, delete) operations related to digital products available for purchase. developers can use this api to view existing in-app products, register new products, modify product details such as price and description, and remove products that are no longer needed. as a part of this article, we will develop a backend application server and a web application to streamline samsung iap product management. the backend server will communicate with the samsung server through the samsung iap publish api, handling requests related to iap products to ensure smooth integration and operation. the web application will provide an intuitive, user-friendly interface, allowing developers and administrators to visually manage samsung iap products in a structured and organized manner. by implementing this system, developers can significantly reduce manual effort while maintaining better control over their iap products. additionally, the publish api enables a unified product backend, helping standardize workflows, enforce consistent policies, and maintain clear audit trails—further enhancing the design and operational efficiency of iap management. to begin, you need to have a mobile application in galaxy store so that you can create samsung iap products. if you do not have one, follow the integration of samsung iap services in android apps article. api overview the samsung iap publish api allows developers to manage iap products in their applications by viewing, creating, updating, modifying, and deleting products. base url the base url for accessing the samsung iap publish api endpoints is. https://devapi.samsungapps.com/iap/v6/applications/:packagename/items replace packagename with the actual package name of your application to access the relevant samsung iap endpoints. supported method the samsung iap publish api allows fetching a list of available products or viewing detailed information about a specific product using get requests. to register a new product, developers can send a post request, while updating an existing product requires a put request. if only partial modifications are needed, a patch request is needed. finally, products can be removed with a delete request. header add the following fields to the request header. authorization: this field requires bearer token which is the access token from galaxy store authentication server. for more information, see the create an access token page. service account id: get the service account id value by clicking the assistance > api service tabs on the seller portal. for more details, read the section create a service account and follow step 6. content-type: use application/json as value. implementation of samsung publish api the samsung iap publish api helps to manage iap products by performing crud operations such as viewing, creating, updating, and removing products. to use these operations, we need to set up a server that processes api requests and executes these operations as instructed. first, create a server. once the server is ready, we can integrate the samsung api for server-to-server communication. in this example, we use okhttp for network communication to call the api. the front-end communicates with the spring boot server, and the spring boot server, in turn, interacts with the samsung iap service. implementation of the "create product" operation a post request is needed to create a new product. for more details, refer to the documentation. private static final string create_api_url = "https://devapi.samsungapps.com/iap/v6/applications/com.example.bookspot/items"; @postmapping(value = "/create", consumes = org.springframework.http.mediatype.application_json_value) public responseentity<string> createitem(@org.springframework.web.bind.annotation.requestbody string requestbody) { okhttp3.mediatype mediatype = okhttp3.mediatype.parse("application/json"); okhttp3.requestbody body = okhttp3.requestbody.create(mediatype, requestbody); request request = new request.builder() .url(create_api_url) .post(body) .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); try (response response = client.newcall(request).execute()) { string responsestring = response.body() != null ? response.body().string() : "no response body"; return responseentity.status(response.code()).body(responsestring); } catch (ioexception e) { return responseentity.status(500).body("error: " + e.getmessage()); } } example response after successful execution of the post request, the server will respond with the status 200 (success). below is the visual representation of the operation. figure 1: ui representation of create product operation for a list of possible response codes when a request fails, refer to failure response codes. implementation of the "view product list" operation to view the already created products, we need to fetch them from the samsung server. for this, we need to build a get request to retrieve the products. for more details, refer to the documentation. private static final string view_api_url = "https://devapi.samsungapps.com/iap/v6/applications/com.example.bookspot/items?page=1&size=20"; @getmapping("/get") public responseentity<string> getrequest() { request request = new request.builder() .url(view_api_url) .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); try (response response = client.newcall(request).execute()) { if (!response.issuccessful()) { string error = response.body() != null ? response.body().string() : "unknown error"; return responseentity.status(response.code()).body("failed: " + error); } string json = response.body() != null ? response.body().string() : "{}"; return responseentity.ok() .contenttype(org.springframework.http.mediatype.application_json) .body(json); } catch (ioexception e) { return responseentity.status(500).body("error: " + e.getmessage()); } } example response after the request is successfully sent to the server, it will respond with the status code 200. below is the visual representation of the product retrieval process. figure 2: ui representation of view product list operation for a list of possible response codes when a request fails, refer to failure response codes. implementation of the "modify product" operation to modify the listed products, we need to create a put request based on the required fields and perform the modification operation accordingly. for more details, refer to the documentation. private static final string modify_api_url = "https://devapi.samsungapps.com/iap/v6/applications/com.example.bookspot/items"; @putmapping(value = "/update", consumes = org.springframework.http.mediatype.application_json_value) public responseentity<string> updateitem(@requestbody string requestbody) { okhttp3.mediatype mediatype = okhttp3.mediatype.parse("application/json"); okhttp3.requestbody body = okhttp3.requestbody.create(mediatype, requestbody); request request = new request.builder() .url(modify_api_url) .put(body) .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); try (response response = client.newcall(request).execute()) { string responsestring = response.body() != null ? response.body().string() : "no response body"; return responseentity.status(response.code()).body(responsestring); } catch (ioexception e) { return responseentity.status(500).body("error: " + e.getmessage()); } example response below is a visual representation of a response to a successful modification request. figure 3: ui representation of modify product operation for a list of possible response codes when a request fails, refer to failure response codes. implementation of the "remove product" operation to delete a product from the server, we need to make a delete request using the necessary fields and execute the item removal operation accordingly. for more details, refer to the documentation. private static final string remove_api_url = "https://devapi.samsungapps.com/iap/v6/applications/com.example.bookspot/items"; @deletemapping("/delete/{itemid}") public responseentity<string> deleteitem(@pathvariable string itemid) { string deleteurl = remove_api_url + "/" + itemid; request request = new request.builder() .url(deleteurl) .delete() .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); try (response response = client.newcall(request).execute()) { string responsestring = response.body() != null ? response.body().string() : "no response body"; return responseentity.status(response.code()).body(responsestring); } catch (ioexception e) { return responseentity.status(500).body("error: " + e.getmessage()); } } example response below is a visual representation of the item retrieval process after a successful remove operation. figure 4: ui representation of delete product operation for a list of possible response codes when a request fails, refer to failure response codes. deploy the server you can deploy your server to codesandbox for testing purposes. you also can use any other hosting site according to your requirements. conclusion by effectively incorporating the samsung iap publish api, you can create your own webview to easily manage your iap products. references for additional information on this topic, refer to the resources. download the sample spring boot server code download the sample structured spring boot server code samsung iap publish documentation

Md. Hossain

https://developer.samsung.com/sdp/blog/en-us/2025/09/04/samsung-iap-publish-api-web-integration

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

Integrating Samsung IAP Subscription Functionalities with Your Server

introduction the samsung iap subscription server apis empower developers to efficiently manage samsung in-app purchase (iap) subscriptions, including cancellation, refund, revocation, and status check. these apis serve as the foundation for implementing subscription management features within your application management server. integrating the samsung iap server apis with your backend server simplifies subscription management. this integration allows you to cancel subscriptions and prevent further billing for users, revoke access to subscription-based content, process refunds based on user requests, and check subscription status to determine validity and current state. a well-structured backend implementation streamlines subscription management, ensuring customers receive reliable service and minimizing potential issues related to billing, access, and refunds. prerequisites to establish server-to-server communication between the samsung iap service and your server, follow these essential steps. develop a subscription application – ensure your application supports subscription operations. upload binary for beta testing – submit your application for testing in seller portal. create subscriptions – set up subscription products in seller portal for user subscriptions. completing these steps ensures a seamless integration of samsung iap into your application. for detailed guidance, visit register an app and in-app items in seller portal. implementation of the samsung subscription apis the samsung iap subscription server apis are used to manage subscription-related operations, including cancellations, revocations, refunds, and status checks. to leverage these apis effectively, setting up a backend server is essential. this secure server-to-server communication facilitates efficient handling of all subscription-related operations between the samsung iap service and your server. api overview the samsung iap subscription server api provides endpoints for efficiently managing subscription-based operations. it allows developers to cancel, revoke, refund, and check the status of subscriptions. this api also facilitates robust operations and efficient management of user subscriptions, all while ensuring security and authentication through the use of appropriate headers. base endpoint the samsung iap subscription server apis need a secure endpoint for managing subscriptions. https://devapi.samsungapps.com/iap/seller/v6/applications/<packagename>/purchases/subscriptions/<purchaseid> more detailed information is available through the support documentation. headers to ensure secure communication with the samsung iap service, the following headers must be included in every request. content-type – defines the format of the request body. for json content, use application/json. authorization – uses an access token for authentication. the format should be (bearer <access_token>). refer to the create an access token page for details on generating an access token. service account id – obtained from seller portal under assistance > api service. this id is required to generate a json web token (jwt). for more detailed information, visit the create a service account section in seller portal. these headers collectively ensure secure and authenticated api requests, enabling seamless integration with the samsung iap service. supported methods the samsung iap subscription server api enables efficient subscription management. developers can cancel, revoke, or refund subscriptions using patch requests, and check subscription status using get requests. configuring the server you can develop a spring boot server for this purpose. here are the guidelines for setting it up. create a spring boot project - for detailed steps, refer to developing your first spring boot application. set up the server endpoint: create a controller for samsung iap subscription apis within your ide after importing the spring boot project. this controller manages all in-app subscription activities. the controller performs patch and get requests with the samsung iap service, ensuring communication with your server. performing a patch request the patch request is used to cancel, refund, or revoke a subscription. follow these steps to proceed. creating a request body to cancel, refund, or revoke a subscription, a specific request body must be created for each operation. when interacting with samsung iap service, you send a well-structured api request tailored to the specific action you wish to execute. below are the request formats for various subscription operations. // cancel a subscription requestbody body = requestbody.create( mediatype.parse("application/json"), "{\"action\" : \"cancel\"}" ); // revoke a subscription requestbody body = requestbody.create( mediatype.parse("application/json"), "{\"action\" : \"revoke\"}" ); // refund a subscription requestbody body = requestbody.create( mediatype.parse("application/json"), "{\"action\" : \"refund\"}" ); building the patch request (cancel, revoke or refund subscription) the patch method in rest apis is used for partial updates of resources, enabling you to send only the specific fields that need modification rather than the entire resource. the patch request needs a request body to specify the intended action. to execute a subscription management request, you must construct a secure http request that includes all necessary headers and authentication details. request request = new request.builder() .url(api_url) .patch(body) .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); executing the patch request once the patch request is prepared, execute it using the okhttpclient, ensuring proper request handling and response processing. @crossorigin(origins = "*") @requestmapping(value = "/cancel", method = requestmethod.patch ) public void patchrequest(){ // set request body as json with required action. // initialize patch request, set body, add headers, and finalize setup. client.newcall(request).enqueue(new callback() { @override public void onfailure(call call, ioexception e) { // handle exception } @override public void onresponse(call call, response response) throws ioexception { // handle response response.close(); } }); } example response this response indicates that the request was processed successfully and without errors. { "code" : "0000", "message" : "success" } performing a get request the get request is used to retrieve the status of a subscription. follow these steps to proceed. building the get request the get method is primarily used to retrieve or read data from a server. to check the status of a subscription, the get method is required to retrieve detailed item information. this type of request does not require a request body; only the necessary headers for authentication are needed. request request = new request.builder() .url(api_url) .addheader("content-type", "application/json") .addheader("authorization", "bearer " + access_token) .addheader("service-account-id", service_account_id) .build(); executing the get request once the get request is prepared, execute it using the okhttpclient to retrieve and efficiently process the response data. @getmapping("/get") public void getrequest(){ // initialize get request, add headers, and finalize setup. client.newcall(request).enqueue(new callback() { @override public void onfailure(call call, ioexception e) { // handle exception } @override public void onresponse(call call, response response) throws ioexception { // handle response } }); } example response if the get request executes successfully, it returns the status of the subscription as a response. { "subscriptionpurchasedate": "2025-04-28 04:54:06 utc", "subscriptionenddate": "2025-04-28 05:54:06 utc", "subscriptionstatus": "cancel", "subscriptionfirstpurchaseid": "55541a3d363c9dee6194614024ee2177c72a9dec51fe8dba5b44503f57dc9aec", "countrycode": "usa", "price": { "localcurrencycode": "usd", "localprice": 15, "supplyprice": 15 }, ... } deploying and testing the server for the server to perform api calls, it can use a publicly accessible url. you can deploy the project to obtain the url. for testing purposes, you might deploy it on a platform like codesandbox, which provides a publicly accessible url similar to https://abcde-8080.csb.app/iap/xxxx. conclusion by properly integrating the samsung iap subscription server apis, developers can ensure seamless handling of subscription-related actions within their applications. the implementation of secure server-to-server communication guarantees efficient subscription management and significantly enhances the overall user experience. references download sample server source code samsung iap subscription documentation integrate the samsung in-app purchase orders api with your application

Md. Hossain

https://developer.samsung.com/sdp/blog/en-us/2025/07/15/integrating-samsung-iap-subscription-functionalities-with-your-server

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 products purchased within mobile apps it ensures a smooth and secure experience when purchasing digital goods or products, managing subscriptions, or dealing with refunds and consumed products the iap sdk makes integrating the iap functionality into your app simple, allowing you to configure iap settings, retrieve product details, offer and sell products, and manage purchased products effortlessly to successfully sell in-app products, 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 products to your app in-app products can be categorized into two types item and subscription item goods and services that charge users on a one-time basis item is a consumable or non-consumable type based on whether it can be repurchased or not subscription a set of benefits that charges users on a recurring basis users can use subscription products as many times as they want during the free trial period or when a paid subscription is active this code lab focuses only on item as the in-app product 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 708 6 kb start your project in android studio, click open to open an existing project locate the downloaded sample project 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 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 5 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 product 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 products 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 products owned by the user the getownedlist function returns a list of products that the user has previously purchased, including items purchased with a single charge to the user's payment method items are either consumable or non-consumable consumable items that have not yet been used and not yet reported as consumed non-consumable items subscriptions that are in a free trial or an 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 for each consumable items which handles consumepurchaseitems api for non-consumable items call handlenonconsumableitems function which handle acknowledgepurchases api 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 getitemid equals "fuel" || item getitemid equals "booster" { // consume the purchased item handleconsumableitems item getpurchaseid ; } else if item getitemid equals "bike" { helperdefine acknowledgedstatus acknowledgedstatus = item getacknowledgedstatus ; if acknowledgedstatus equals helperdefine acknowledgedstatus not_acknowledged { handlenonconsumableitems item getpurchaseid ; } } } } else { log d "getownedproducts failed ", errorvo tostring ; } } } ; notecall getownedlist whenever launching the application to check for unconsumed items or subscription availability use the acknowledgepurchases api as below iaphelper acknowledgepurchases purchaseid, new onacknowledgepurchaseslistener { @override public void onacknowledgepurchases @nonnull errorvo errorvo, @nonnull arraylist<acknowledgevo> acknowledgedlist { if errorvo geterrorcode == iaphelper iap_error_none { for acknowledgevo item acknowledgedlist { log i "acknowledged purchases ", item getstatusstring ; } } else { log e "acknowledged purchases error ", errorvo geterrorstring ; } } } ; 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 purchaseid, 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 products 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 products 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 use obfuscatedaccountid and obfuscatedprofileid value is up to 64 bytes to detect fraudulent payments these values are returned in purchasevo 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, obfuscatedaccountid, obfuscatedprofileid, 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" { handlenonconsumableitems purchasevo getpurchaseid ; // update ui 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 api is called through the handleconsumableitems function for a non-consumable item, the acknowledgepurchases api is called through the handlenonconsumableitems 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 710 1 kb to learn more, explore samsung in-app purchase

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

Develop Samsung IAP

doc

Samsung In-App Purchase Test Guide — Manage Testers

tester types for samsung in-app purchase iap products, there are three types of testers beta tester, non-license tester, and license tester the test environment for each type of tester is determined by your test type beta or non-beta testing and the iap operation mode you can register the beta tester and license tester in seller portal a tester registered in seller portal must use an email address that is registered to a samsung account must be registered in seller portal before you submit your app for testing if you want to add or remove testers from your app after you have deployed it, you must update the app, update the list of testers, and, after saving your changes, wait 10 minutes for the changes to take effect see update tester list after deployment for more information beta tester a beta tester is a user who is registered in seller portal and can download your app using the beta test url a beta tester can only be registered if you are conducting a closed beta test for information about adding a closed beta test and beta testers, see how to add a closed beta test and testers to your app non-license tester a non-license tester is a user who is not registered as a license tester in seller portal in a closed beta test, if you want the non-license tester to be able to install your test app using the beta testing url, you must register the non-license tester as a beta tester when a non-license tester is able to make purchases, they are charged for their purchases the table below summarizes the test environment and purchase behavior for a non-license tester test type iap operation mode purchase behavior beta closed beta test andnon-beta test,test_failure cannot purchase production charged for purchases license tester a license tester is a user who is registered as a license tester in seller portal the purpose of registering a license tester is so that they are not charged for purchases while testing in most situations they are not charged, see the table below in a closed beta test, if you want the license tester to be able to install your test app using the beta testing url, you must also register the license tester as a beta tester for information about adding a license tester from your seller portal profile, see the step to add a license tester from your seller profile for information about adding a closed beta test and beta testers, see how to add a closed beta test and testers to your app the table below summarizes the test environment and purchase behavior for a license tester test type iap operation mode purchase behavior test environment beta closed beta test test,test_failure not charged for purchases sandboxcan repurchase non-consumable items after 10 minsubscription periods are accelerated to 10 mina subscription is automatically canceled after 12 renewalsone-day grace periods are accelerated to 10 min production non-beta test,test_failure not charged for purchases sandboxcan repurchase non-consumable items after 10 minsubscription periods are accelerated to 10 mina subscription is automatically canceled after 12 renewalsone-day grace periods are accelerated to 10 min production charged for successful purchases n/a

https://developer.samsung.com/iap/test-guide/tester-types.html

Develop Samsung IAP

doc

Samsung In-App Purchase Test Guide — Prepare for Production

prepare for production complete all of these steps before submitting your app and samsung in-app purchase iap products for validation testing in seller portal and publication in galaxy store noteyou can only track the purchase history of a beta test app during the beta testing period when the app is updated to a regular non-beta installation, beta test purchase history is no longer available in the app code, confirm the iap operating mode is set to operation_mode_production cautionif you submit an app with the iap operating mode set to operation_mode_test, license testers will not be charged for purchases all other users will receive an error message in seller portal, if the app was changed after iap testing, update the app registration information with the production version and revise any additional information, as needed submit the app for validation testing and normal publication see the application registration guide

https://developer.samsung.com/iap/test-guide/prepare-for-production.html

Develop Samsung IAP

doc

Samsung In-App Purchase Test Guide — Test Subscriptions

subscription testing examples the following tables show expected system events and tester actions for each subscription scenario in the sandbox test environment all times are local time hh mm all examples use 10-minute test periods non-introductory subscription purchase, free trial and automatic cancellation after 12th auto-payment the test subscription has a 1-month free trial period and a regular $4 99 monthly subscription price system time tester action system event subscription status expirationdate & time 15 jan, 2026, 13 03 purchase subscription starts free trial period 15 feb, 2026, 13 03 15 jan, 2026, 13 10 1st auto-payment regular price period 15 mar, 2026, 13 03 15 jan, 2026, 13 20 2nd auto-payment regular price period 15 apr, 2026, 13 03 15 jan, 2026, 13 30 3rd auto-payment regular price period 15 may, 2026, 13 03 ⋮ ⋮ ⋮ ⋮ 15 jan, 2026, 14 40 10th auto-payment regular price period 15 dec, 2026, 13 03 15 jan, 2026, 14 50 11th auto-payment regular price period 15 jan, 2027, 13 03 15 jan, 2026, 15 00 12th auto-payment regular price period 15 feb, 2027, 13 03 15 jan, 2026, 15 10 auto-payment stops expired 15 jan, 2026, 15 20* * after 12 automatic payments, the expiration date changes to the current date and time, allowing new purchases introductory subscription purchase, free trial and automatic cancellation after 12th auto-payment the test subscription has a 1-month free trial period, a $2 99 introductory monthly subscription price for 3 months, and a $4 99 regular-tier monthly subscription price system time tester action system event subscription status expirationdate & time 15 jan, 2026, 13 03 purchase subscription starts free trial period 15 feb, 2026, 13 03 15 jan, 2026, 13 10 1st auto-payment introductory price period 15 mar, 2026, 13 03 15 jan, 2026, 13 20 2nd auto-payment introductory price period 15 apr, 2026, 13 03 15 jan, 2026, 13 30 3rd auto-payment introductory price period 15 may, 2026, 13 03 15 jan, 2026, 13 40 4th auto-payment regular price period 15 jun, 2026, 13 03 ⋮ ⋮ ⋮ ⋮ 15 jan, 2026, 14 40 10th auto-payment regular price period 15 dec, 2026, 13 03 15 jan, 2026, 14 50 11th auto-payment regular price period 15 jan, 2027, 13 03 15 jan, 2026, 15 00 12th auto-payment regular price period 15 feb, 2027, 13 03 15 jan, 2026, 15 10 auto-payment stops expired 15 jan, 2026, 15 20* * after 12 automatic payments, the expiration date changes to the current date and time, allowing new purchases non-introductory subscription purchase, free trial, manual cancellation the test subscription has a 1-month free trial period and a $4 99 regular-tier monthly subscription price system time tester action system event subscription status expirationdate & time 15 jan, 2026, 13 03 purchase subscription starts free trial period 15 feb, 2026, 13 03 15 jan, 2026, 13 10 1st auto-payment regular price period 15 mar, 2026, 13 03 15 jan, 2026, 13 20 2nd auto-payment regular price period 15 apr, 2026, 13 03 15 jan, 2026, 13 25 manual cancellation* auto-payment stops regular price period 15 jan, 2026, 13 30 15 jan, 2026, 13 30 auto-payment stops expired 15 jan, 2026, 13 30 * when a subscription is cancelled in test mode, the subscription expires at the end of the current test cycle — the next 10-minute mark of the hour for example, hh 00, hh 10, hh 20, hh 30, hh 40, hh 50 non-introductory subscription purchase, free trial, manual cancellation, and re-subscription from galaxy store the test subscription has a 1-month free trial period and a $4 99 regular-tier monthly subscription price system time tester action system event subscription status expirationdate & time 15 jan, 2026, 13 03 purchase subscription starts free trial period 15 feb, 2026, 13 03 15 jan, 2026, 13 10 1st auto-payment regular price period 15 mar, 2026, 13 03 15 jan, 2026, 13 20 2nd auto-payment regular price period 15 apr, 2026, 13 03 15 jan, 2026, 13 25 manual cancellation* auto-payment stops regular price period 15 jan, 2026, 13 30 15 jan, 2026, 13 28 resubscribe from galaxy store** auto-payment restarts regular price period 15 apr, 2026, 13 03 15 jan, 2026, 13 30 3rd auto-payment regular price period 15 may, 2026, 13 03 15 jan, 2026, 13 40 4th auto-payment regular price period 15 jun, 2026, 13 03 15 jan, 2026, 13 50 5th auto-payment regular price period 15 jul, 2026, 13 03 ⋮ ⋮ ⋮ ⋮ 15 jan, 2026, 14 40 10th auto-payment regular price period 15 dec, 2026, 13 03 15 jan, 2026, 14 50 11th auto-payment regular price period 15 jan, 2027, 13 03 15 jan, 2026, 15 00 12th auto-payment regular price period 15 feb, 2027, 13 03 15 jan, 2026, 15 10 auto-payment stops expired 15 jan, 2026, 15 10*** * when a subscription is cancelled in test mode, the subscription expires at the end of the current test cycle — the next 10-minute mark of the hour for example, hh 00, hh 10, hh 20, hh 30, hh 40, hh 50 ** re-subscription is only possible before the end of the current test cycle after cancellation *** after 12 automatic payments, the expiration date changes to the current date and time, allowing new purchases

https://developer.samsung.com/iap/test-guide/subscription-testing-examples.html

Develop Samsung IAP

doc

Samsung In-App Purchase Test Guide — Overview

samsung iap test guide samsung in-app purchase iap supports the testing of your in-app product offerings when your app retrieves and displays product details and prices , purchase, and payment functionality before you submit your app to validation testing and publication in galaxy store iap testing follows the same flow of in-app product purchases and payments except that subscription cycle lengths differ and some testers get products for free it is recommended that, at a minimum, you perform at least one closed beta test and test your iap products before publishing your app this guide covers how to prepare your app, in-app products, and testers for iap testing it also describes the testing process and the steps needed to move the app from testing to production tester types — tester types and in what environment they should be used iap operation modes — how each operation mode behaves and the expected results prepare to test — steps to set up your app, in-app products, and seller portal listing to prepare for testing test product offerings and items — view product offerings and test consumable and non-consumable in-app items test subscriptions — test a subscription subscription testing examples — example timelines of system events and tester actions prepare for production — steps to take before submitting your app for validation testing and publication

https://developer.samsung.com/iap/test-guide/overview.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.