--- title: "Customer center" slug: "game-gamepot3-customer-support" updated: 2026-10-08T02:15:57Z published: 2026-10-08T02:15:57Z canonical: "guide.ncloud-docs.com/game-gamepot3-customer-support" --- > ## Documentation Index > Fetch the complete documentation index at: https://guide.ncloud-docs.com/llms.txt > Use this file to discover all available pages before exploring further. # Customer center Available in Classic and VPC We provide support for various user inquiries, including Terms and Conditions, Privacy Policy, refund policy announcements, in-game instructions, payment and refund inquiries, account management, bug reports, and suggestions. Users can submit inquiries in-game or from their PC. When submitting an inquiry, you can also attach files such as images and videos. The mobile game customer support center plays an important role in helping users have a pleasant gaming experience. By listening to users and responding quickly, you should strive to provide a better gaming environment. The support is available in 12 languages: English, Korean, Chinese (Traditional), Chinese (Simplified), Japanese, Thai, Hindi, Italian, German, Spanish, French, and Malaysian. For inquiries about additional language support, please contact the NAVER Cloud customer support center. ## Usage method All features related to the customer center UI and operation are provided by GAMEPOT. You can configure settings for each feature in Support > Settings on the GAMEPOT dashboard. ## Support feature This section describes the customer support webview and page call features provided by the GAMEPOT SDK. ### Terms and Conditions webview To call the Terms and Conditions, call the following code. - C#: ``` NBaseSDK.NBase.openTerms(); ``` - Kotlin: ``` NBase.openTerms(activity) { status, error -> if (error != null) { // openTerms Failed Log.e("NBase", "openTerms Failed: ${error.message}") } else { // openTerms Success Log.d("NBase", "openTerms Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openTerms(activity, (status, e) -> { if (e != null) { Log.e("NBase", "openTerms Fail: " + e.getMessage()); } else { Log.d("NBase", "openTerms Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openTerms() ``` - Objective-C: ``` [NBaseBridge.shared openTerms]; ``` The following table describes the parameters passed when calling `openTerms`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | The following table describes the values passed by the `openTerms` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ### Privacy Policy webview To call the Privacy Policy, call the following code. - C#: ``` NBaseSDK.NBase.openPrivacy(); ``` - Kotlin: ``` NBase.openPrivacy(activity) { status, error -> if (error != null) { // openPrivacy Failed Log.e("NBase", "openPrivacy Failed: ${error.message}") } else { // openPrivacy Success Log.d("NBase", "openPrivacy Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openPrivacy(activity, (status, e) -> { if (e != null) { Log.e("NBase", "openPrivacy Fail: " + e.getMessage()); } else { Log.d("NBase", "openPrivacy Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openPrivacy() ``` - Objective-C: ``` [NBaseBridge.shared openPrivacy]; ``` The following table describes the parameters passed when calling `openPrivacy`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | The following table describes the values passed by the `openPrivacy` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ### Webview GAMEPOT webview provides the ability to display web content directly within a native app. This allows users to access a variety of web-based content without leaving the game. To call the GAMEPOT webview, call the following code. - C#: ``` NBaseSDK.NBase.openWebView("https://guide.ncloud-docs.com"); ``` - Kotlin: ``` NBase.openWebView(activity, "https://guide.ncloud-docs.com") { status, error -> if (error != null) { // openWebView Failed Log.e("NBase", "openWebView Failed: ${error.message}") } else { // openWebView Success Log.d("NBase", "openWebView Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openWebView(activity, "https://guide.ncloud-docs.com", (status, e) -> { if (e != null) { Log.e("NBase", "openWebView Fail: " + e.getMessage()); } else { Log.d("NBase", "openWebView Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openWebView(url: "https://guide.ncloud-docs.com") ``` - Objective-C: ``` [NBaseBridge.shared openWebView:@"https://guide.ncloud-docs.com"]; ``` The following table describes the parameters passed when calling `openWebView`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | | url | String | URL of the web page to display | O | The following table describes the values passed by the `openWebView` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ### Page Page service provides the ability to create and manage web pages for various purposes, including in-game terms and conditions, privacy policy, etc. Users can design and configure pages directly through the web editor on the dashboard, and then easily display them in the form of webviews within the mobile game. This enables game developers to effectively provide necessary information to game users. To call the Page feature, call the following code. - C#: ``` NBaseSDK.NBase.openPage(pageId); ``` - Kotlin: ``` NBase.openPage(activity, pageId) { status, error -> if (error != null) { // openPage Failed Log.e("NBase", "openPage Failed: ${error.message}") } else { // openPage Success Log.d("NBase", "openPage Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openPage(activity, pageId, (status, e) -> { if (e != null) { Log.e("NBase", "openPage Fail: " + e.getMessage()); } else { Log.d("NBase", "openPage Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openPage(pageId: pageId) ``` - Objective-C: ``` [NBaseBridge.shared openPage: pageId]; ``` The following table describes the parameters passed when calling `openPage`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | | pageId | String | Dashboard > Support > Page > {pageId} value in the web access address pages/{pageId} | O | The following table describes the values passed by the `openPage` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ### Go to store To provide users with the latest version of the game, the ability to go directly to the app store's update page from within the game is very important. To this end, the openAppStore method is used to allow users to easily update to the latest version of the game. To direct users to the update page of the app store for game updates, you need to set the store-specific market code on the dashboard. After the settings are complete, use the code below to direct users to the update page of the app store. - C#: ``` NBaseSDK.NBase.openAppStore(); ``` - Kotlin: ``` NBase.openAppStore(activity) { status, error -> if (error != null) { // openAppStore Failed Log.e("NBase", "openAppStore Failed: ${error.message}") } else { // openAppStore Success Log.d("NBase", "openAppStore Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openAppStore(activity, (status, e) -> { if (e != null) { Log.e("NBase", "openAppStore Fail: " + e.getMessage()); } else { Log.d("NBase", "openAppStore Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openAppStore() ``` - Objective-C: ``` [NBaseBridge.shared openAppStore]; ``` The following table describes the parameters passed when calling `openAppStore`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | The following table describes the values passed by the `openAppStore` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ## Notice This section describes how to view the notice banners registered on the dashboard and display them on the game page. ### Import notice information This feature imports the notice banner information set on the dashboard. To import the notice banner information, call the following code. - C#: ``` NBaseSDK.NBase.getBanners("url", (banners, error) => { if (error != null) { // getBanners Failed Debug.Log("getBanners Failed: " + error.Message.ToString()); } else { // getBanners Success Debug.Log("getBanners Success: " + banners.ToString()); } }); ``` - Kotlin: ``` NBase.getBanners("url") { banners, error -> if (error != null) { // getBanners Failed Log.e("NBase", "getBanners Failed: ${error.message}") } else { // getBanners Success Log.d("NBase", "getBanners Success: $banners") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.getBanners("url", (banners, e) -> { if (e != null) { Log.e("NBase", "getBanners Fail: " + e.getMessage()); } else { Log.d("NBase", "getBanners Success: " + banners.toString()); } return null; }); ``` - Swift: ``` NBase.getBanners(type: "url") { result in switch result { case .success(let banners): // getBanners Success print("getBanners Success: \(banners)") case .failure(let error): // getBanners Failed print("getBanners Failed: \(error.localizedDescription)") } } ``` - Objective-C: ``` [NBaseBridge.shared getBanners:@"url" :^(NSDictionary * _Nullable result, NSError * _Nullable error) { if (error) { // getBanners Failed NSLog(@"getBanners Failed: %@", error.localizedDescription); } else { // getBanners Success NSLog(@"getBanners Success: %@", result); } }]; ``` The following table describes the parameters passed when calling `getBanners`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | type | String | Banner type - "url": Banner linked to a web URL - "scheme": Banner linked to scheme | O | The following table describes the values passed by the `getBanners` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | banners | List | Banner list | ### Call notice pop-up The Notice feature shows the image set on the dashboard in the game. You can open a specific link with a click event. In Android SDK 3.0.96, iOS SDK 3.0.65, and Unity SDK 3.0.18 or later, you can configure the appearance (linear or dotted), color, and auto-scroll interval of the banner page indicator. The following is an example that uses all of these options. - C#: ``` NBaseSDK.NBase.openBanner( "url", true, true, "#FFFFFF", "#808080", "5", (bannerId, error) => { if (error != null) { Debug.Log("openBanner Failed: " + error.Message); return; } Debug.Log("openBanner Success: " + bannerId); } ); ``` - Kotlin: ``` NBase.openBanner( activity, "url", true, true, "#FFFFFF", "#808080", "5" ) { bannerId, error -> if (error != null) { // openBanner Failed Log.e("NBase", "openBanner Failed: ${error.message}") } else { // openBanner Success Log.d("NBase", "openBanner Success: $bannerId") } } ``` - Java: ``` NBase.INSTANCE.openBanner( activity, "url", true, true, "#FFFFFF", "#808080", "5", (bannerId, error) -> { if (error != null) { Log.e("NBase", "openBanner Failed: " + error.getMessage()); } else { Log.d("NBase", "openBanner Success: " + bannerId); } return null; } ); ``` - Swift: ``` NBase.openBanner( type: "url", showTodayButton: true, useLineIndicator: true, activeColorHex: "#FFFFFF", inactiveColorHex: "#808080", rollSecond: "5" ) { result in switch result { case .success(let bannerId): // openBanner Success print("openBanner Success: \(bannerId)") case .failure(let error): // openBanner Failed print("openBanner Failed: \(error.localizedDescription)") } } ``` - Objective-C: ``` [NBaseBridge.shared openBanner:@"url" showTodayButton:YES useLineIndicator:YES activeColorHex:@"#FFFFFF" inactiveColorHex:@"#808080" rollSecond:@"5" :^(NSDictionary * _Nullable result, NSError * _Nullable error) { if (error) { // openBanner Failed NSLog(@"openBanner Failed: %@", error.localizedDescription); } else { // openBanner Success NSLog(@"openBanner Success: %@", result); } }]; ``` The following table describes the parameters passed when calling `openBanner`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | | type | String | Banner type - `url`: Banner linked via web URL. - `scheme`: Banner linked via scheme. | O | | showTodayButton | Boolean | Whether to display the **[Do not show today]** button. | O | | useLineIndicator | Boolean | Banner page indicator shape. - `true`: Linear - `false`: Dot | X | | activeColor / activeColorHex | String | Current page indicator color (hexadecimal color string). - iOS uses `activeColorHex`. | X | | inactiveColor / inactiveColorHex | String | Inactive page indicator color (hexadecimal color string). - iOS uses `inactiveColorHex`. | X | | rollSecond | String | Banner auto-scroll interval (seconds). - If left blank or a value less than or equal to 0 is passed, auto-scroll is not used. | X | The following table describes the values passed by the `openBanner` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | bannerId | String | URL or scheme of the clicked banner | | error | Error | Error information when banner display fails | ## Customer inquiry This section describes how to call the customer support webview so that users can access the customer support menu within the game. ### Support webview Support webview is a feature that displays a web view within the game that allows users to access menus such as inquiries, notices, and FAQs. To call the Support webview, use the following code. - C#: ``` NBaseSDK.NBase.openCustomerSupport(); ``` - Kotlin: ``` NBase.openCustomerSupport(activity) { status, error -> if (error != null) { // openCustomerSupport Failed Log.e("NBase", "openCustomerSupport Failed: ${error.message}") } else { // openCustomerSupport Success Log.d("NBase", "openCustomerSupport Success: $status") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openCustomerSupport(activity, (status, e) -> { if (e != null) { Log.e("NBase", "openCustomerSupport Fail: " + e.getMessage()); } else { Log.d("NBase", "openCustomerSupport Success: " + status.toString()); } return null; }); ``` - Swift: ``` NBase.openCustomerSupport() ``` - Objective-C: ``` [NBaseBridge.shared openCustomerSupport]; ``` The following table describes the parameters passed when calling `openCustomerSupport`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | The following table describes the values passed by the `openCustomerSupport` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | status | Boolean | Success or Failure | ## Agree to Terms and Conditions This section describes how to display the Terms and Conditions and Privacy Policy together and obtain user consent. ### Agree to terms and conditions and privacy policy This feature displays the terms and conditions and privacy policy together and obtains the user's consent to push notifications and the terms and conditions. - C#: ``` NBaseSDK.NBase.openTermsAndPrivacy((agreement, error) => { if (error != null) { // openTermsAndPrivacy Failed Debug.Log("openTermsAndPrivacy Failed: " + error.Message.ToString()); } else { // openTermsAndPrivacy Success Debug.Log("openTermsAndPrivacy Success: " + agreement.ToString()); } }); ``` - Kotlin: ``` NBase.openTermsAndPrivacy(activity) { agreement, error -> if (error != null) { // openTermsAndPrivacy Failed Log.e("NBase", "openTermsAndPrivacy Failed: ${error.message}") } else { // openTermsAndPrivacy Success Log.d("NBase", "openTermsAndPrivacy Success: $agreement") } } ``` - Java: ``` NBase nBase = NBase.INSTANCE; nBase.openTermsAndPrivacy(activity, (agreement, e) -> { if (e != null) { Log.e("NBase", "openTermsAndPrivacy Fail: " + e.getMessage()); } else { Log.d("NBase", "openTermsAndPrivacy Success: " + agreement.toString()); } return null; }); ``` - Swift: ``` NBase.openTermsAndPrivacy { result in switch result { case .success(let agreement): // openTermsAndPrivacy Success print("openTermsAndPrivacy Success: \(agreement)") case .failure(let error): // openTermsAndPrivacy Failed print("openTermsAndPrivacy Failed: \(error.localizedDescription)") } } ``` - Objective-C: ``` [NBaseBridge.shared openTermsAndPrivacy:^(NSDictionary * _Nullable result, NSError * _Nullable error) { if (error) { // openTermsAndPrivacy Failed NSLog(@"openTermsAndPrivacy Failed: %@", error.localizedDescription); } else { // openTermsAndPrivacy Success NSLog(@"openTermsAndPrivacy Success: %@", result); } }]; ``` The following table describes the parameters passed when calling `openTermsAndPrivacy`. - **Parameter** | Key | Type | Description | Required | | --- | --- | --- | --- | | activity | Activity | Current activity (only applicable for Android) | O | The following table describes the values passed by the `openTermsAndPrivacy` callback. - **Callback** | Key | Type | Description | | --- | --- | --- | | agreement | Agreement | Consent result information |