NAVER SDKs & Libraries for Android & iOS (2026)

SDKs overview

NAVER provides Software Development Kits (SDKs) and libraries designed to facilitate the integration of its services into external applications. These tools are primarily focused on mobile platforms, specifically Android and iOS, reflecting NAVER's strong presence in the South Korean mobile market. The SDKs abstract complex API interactions, offering developers simplified methods for implementing features such as user authentication via Naver Login, displaying interactive maps, and accessing various content and community services like Naver Search results, blogs, and cafes.

The official SDKs are supported with documentation available on the NAVER Developer Center. They offer functionalities ranging from streamlined user authentication processes, which are critical for applications targeting the South Korean user base, to enabling rich location-based services through Naver Maps. These SDKs are developed and maintained by NAVER, ensuring compatibility and optimal performance with their backend services. The use of SDKs can significantly reduce development time and effort by providing pre-built and tested modules for common integration tasks.

Official SDKs by language

NAVER offers official SDKs primarily for Android and iOS development. These SDKs are tailored to integrate specific NAVER services into mobile applications. The primary focus is on services vital for the Korean market, such as user authentication and mapping functionalities. The official documentation provides comprehensive guides for each SDK, detailing their capabilities and usage. For example, the Naver Login SDK allows applications to implement a secure and convenient login method for NAVER users, while the Naver Maps SDK enables the embedding of customizable map views and location-based features.

Installation

Installing NAVER SDKs typically involves adding dependencies to your project's build configuration. The exact steps vary slightly between Android and iOS projects, aligning with their respective package management systems.

Android (Naver Login SDK example)

For Android applications, you typically add the SDK as a dependency in your build.gradle file. Ensure your project targets the correct SDK versions as specified in the Naver Android Login documentation.

// build.gradle (Module: app)
dependencies {
    implementation 'com.naver.nid:naveridlogin-android-sdk:5.4.0' // Check for latest version
}

After adding the dependency, synchronize your Gradle project. You might also need to add specific permissions to your AndroidManifest.xml for internet access and other functionalities required by the SDK.

iOS (Naver Login SDK example)

For iOS projects, the recommended method for installing NAVER SDKs is through CocoaPods. First, ensure CocoaPods is installed on your system. Then, navigate to your project directory in the terminal and create or open your Podfile.

# Podfile
target 'YourAppTarget' do
  use_frameworks!
  pod 'NaverThirdPartyLogin', '~> 4.1.6' // Check for latest version
  # For Naver Maps SDK, you might add:
  # pod 'NMapsMap', '~> 3.16.0'
end

After adding the pod entry, run pod install in your terminal. This will integrate the SDK into your Xcode project. Further configuration, such as setting up URL schemes and bundle identifiers, is required as detailed in the Naver iOS Login SDK guide.

Quickstart example

This quickstart demonstrates how to initialize the Naver Login SDK and perform a basic login request on Android. Similar principles apply to iOS, though the syntax and specific classes will differ.

Android (Naver Login)

First, initialize the Naver ID Login SDK within your Application class or your main Activity. Ensure you have registered your application and obtained the client ID, client secret, and service URL scheme from the NAVER Developer Console.

import com.navercorp.nid.NaverIdLoginSDK
import android.app.Application

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        NaverIdLoginSDK.initialize(
            this,
            "YOUR_NAVER_CLIENT_ID",
            "YOUR_NAVER_CLIENT_SECRET",
            "YOUR_NAVER_APP_NAME"
        )
    }
}

To initiate the login flow from an Activity (e.g., a login button click):

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.navercorp.nid.NaverIdLoginSDK
import com.navercorp.nid.oauth.NidOAuthLogin
import com.navercorp.nid.oauth.OAuthLoginCallback
import android.widget.Button
import android.widget.Toast

class LoginActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)

        val naverLoginButton: Button = findViewById(R.id.naver_login_button)
        naverLoginButton.setOnClickListener {
            startNaverLogin()
        }
    }

    private fun startNaverLogin() {
        val mOAuthLoginCallback = object : OAuthLoginCallback {
            override fun onSuccess() {
                // Login successful. You can now get tokens and user info.
                val accessToken = NaverIdLoginSDK.get : NaverIdLoginSDK.getAccessToken()
                val refreshToken = NaverIdLoginSDK.get : NaverIdLoginSDK.getRefreshToken()
                val expiresIn = NaverIdLoginSDK.get : NaverIdLoginSDK.getExpiresAt()
                val tokenType = NaverIdLoginSDK.get : NaverIdLoginSDK.getTokenType()

                Toast.makeText(this@LoginActivity, "Login Success! Access Token: $accessToken", Toast.LENGTH_SHORT).show()
                // Navigate to main activity or fetch user profile
            }
            override fun onFailure(httpStatus: Int, message: String) {
                val errorCode = NaverIdLoginSDK.getLastErrorCode().code
                val errorDescription = NaverIdLoginSDK.getLastErrorDescription()
                Toast.makeText(this@LoginActivity, "Login Failed: $errorDescription", Toast.LENGTH_SHORT).show()
            }
            override fun onError(errorCode: Int, message: String) {
                onFailure(errorCode, message)
            }
        }
        NaverIdLoginSDK.authenticate(this, mOAuthLoginCallback)
    }
}

Community libraries

While NAVER provides official SDKs for essential services, the developer community also contributes libraries and wrappers that extend or simplify interactions with various NAVER APIs. These community-driven projects can offer alternative language bindings, specific framework integrations (e.g., React Native, Flutter), or specialized tools not officially supported by NAVER.

Community libraries often emerge to fill gaps, provide idiomatic implementations for different programming paradigms, or support less common platforms. For instance, developers might find third-party wrappers for accessing Naver Search API, Papago Translate API, or other RESTful services offered by NAVER, written in languages like Python or JavaScript. These can be particularly useful for backend integrations or web applications that do not directly use the mobile-focused official SDKs.

When considering community libraries, it is important to evaluate their maintenance status, documentation quality, and community support. Resources like GitHub or package managers (e.g., npm, PyPI) are common places to discover such projects. However, it's worth noting that community libraries may not always keep pace with the latest API changes or maintain the same level of security and reliability as official SDKs. For example, a developer might find a Python client for Naver APIs on GitHub, which provides a convenient way to interact with services like search or translation without directly using the official mobile SDKs.

Developers should always consult the official NAVER API reference documentation to understand the underlying API specifications, regardless of whether they are using an official SDK or a community-contributed library. This ensures that the chosen library correctly implements the API protocols and adheres to rate limits and authentication requirements.

For cross-platform development frameworks like React Native or Flutter, community members often create bridges or plugins that allow JavaScript or Dart code to interact with the native NAVER SDKs. These solutions abstract the native code, enabling a single codebase to utilize NAVER's mobile services across both Android and iOS. While convenient, the stability and feature parity of these community integrations can vary, so thorough testing and review of their source code are recommended before production use.