kakao developers

iOS

This document describes how to integrate Kakao Login APIs into your service with the Kakao SDK for iOS.

To learn about each API in detail, refer to Concepts.

For a Kakao Login button, you can download the resources provided by Kakao or customize buttons according to your service user interface by referring to the Design Guide.

Kakao Login button resource downloadoutlinkDesign Guide

Before you begin

Before using Kakao Login APIs with the iOS SDK,

1. Register the iOS platform.
2. Add modules.
3. Optional: Configure for Login with Kakao Talk.

Add modules

To implement Kakao Login, you need to install both the Kakao Login and Authentication modules. After adding KakaoSDKAuth (Authentication and token management module) and KakaoSDKUser (Kakao Login module) to the Podfile, add the import statement for the modules as follows.

Sample

import KakaoSDKCommon
import KakaoSDKAuth
import KakaoSDKUser

import KakaoSDKCommon
import RxKakaoSDKCommon
import KakaoSDKAuth
import RxKakaoSDKAuth
import KakaoSDKUser
import RxKakaoSDKUser

Configuration for Login with Kakao Talk*

*This configuration is required for Login with Kakao Talk.

The Login with Kakao Talk allows users to move to Kakao Talk from a service app and go back to the app when the user selects [Accept and Continue] or [Cancel] on Kakao Talk. To implement this process, you must configure these things:

1. Register Allowlist to allow Kakao Talk to run from your service app by referring to Register Allowlist.
2. Set a Custom URL Scheme used to open Kakao Talk.
3. Add the handleOpenUrl() method that asks to open the URL in the AppDelegate.swift file to complete the login process after coming back to the service app.

Sample

import KakaoSDKAuth
...

class AppDelegate: UIResponder, UIApplicationDelegate {
    ...
    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        if (AuthApi.isKakaoTalkLoginUrl(url)) {
            return AuthController.handleOpenUrl(url: url)
        }

        return false
    }
    ...
}

import RxKakaoSDKAuth
import KakaoSDKAuth
...

class AppDelegate: UIResponder, UIApplicationDelegate {
    ...
    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        if (AuthApi.isKakaoTalkLoginUrl(url)) {
            return AuthController.rx.handleOpenUrl(url: url)
        }

        return false
    }
    ...
}

If you make a project for an app in iOS 13 or higher, UIApplicationSceneManifest is added in the Info.plist file and UISceneDelegate.swift is set to use as a default. If you use UISceneDelegate.swift, add the handleOpenUrl() method in the SceneDelegate.swift file, instead of the AppDelegate.swift file.

If you use the SwiftUI App Life Cycle, add handleOpenUrl() inside the ${PROJECT_NAME}App class using onOpenURL() in the same way with initializing SDK.

Sample

import KakaoSDKAuth
...

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    ...
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            if (AuthApi.isKakaoTalkLoginUrl(url)) {
                _ = AuthController.handleOpenUrl(url: url)
            }
        }
    }
    ...
}

import RxKakaoSDKAuth
import KakaoSDKAuth
...

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    ...
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            if (AuthApi.isKakaoTalkLoginUrl(url)) {
                _ = AuthController.rx.handleOpenUrl(url: url)
            }
        }
    }
    ...
}

import SwiftUI
import KakaoSDKCommon
import KakaoSDKAuth
...

@main
struct SwiftUI_testApp: App {

    ...
    init() {
        // Initialize Kakao SDK.
        KakaoSDK.initSDK(appKey: "NATIVE_APP_KEY")
    }

    var body: some Scene {
        WindowGroup {
            // Handle Custom URL Scheme using onOpenURL().
            ContentView().onOpenURL(perform: { url in
                if (AuthApi.isKakaoTalkLoginUrl(url)) {
                    AuthController.handleOpenUrl(url: url)
                }
            })
        }
    }
    ...

}

Login

The Login API enables users to log in through Kakao Talk or their Kakao Account information.

Login with Kakao Talk

For Login with Kakao Talk, you must configure some settings in advance.

After configuration, call the isKakaoTalkLoginAvailable() method that invokes the loginWithKakaoTalk() method to check if Kakao Talk has been installed on a user's device. loginWithKakaoTalk() runs Kakao Talk and prompts the Consent screen that asks consent.

To handle exceptions, refer to the AuthFailureReason section in API Reference.

Parameter

Sample

// Check if Kakao Talk has been installed.
if (UserApi.isKakaoTalkLoginAvailable()) {
    UserApi.shared.loginWithKakaoTalk {(oauthToken, error) in
        if let error = error {
            print(error)
        }
        else {
            print("loginWithKakaoTalk() success.")

            // Do something
            _ = oauthToken            
        }
    }    
}

// Class member property
let disposeBag = DisposeBag()

// Check if Kakao Talk has been installed.
if (UserApi.isKakaoTalkLoginAvailable()) {   
    UserApi.shared.rx.loginWithKakaoTalk()
        .subscribe(onNext:{ (oauthToken) in
            print("loginWithKakaoTalk() success.")
        
            // Do something
             _ = oauthToken
        }, onError: {error in
            print(error)
        })
    .disposed(by: disposeBag)
}

When a user consents, Kakao identifies the user with the user's Kakao Account information linked to Kakao Talk, and then issues tokens. The iOS SDK provides the issued tokens through the OAuthToken object.

OAuthToken

The issued tokens are stored through the TokenManagerProvider class. The stored tokens are automatically added to the authorization header when calling the token-based APIs.

Login with Kakao Account

For Login with Kakao Account, call the loginWithKakaoAccount() method that runs a web browser and prompts the Consent screen that asks consent.

Parameter

Sample

UserApi.shared.loginWithKakaoAccount {(oauthToken, error) in
        if let error = error {
            print(error)
        }
        else {
            print("loginWithKakaoAccount() success.")            

            // Do something
             _ = oauthToken            
        }
    }

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.loginWithKakaoAccount()
    .subscribe(onNext:{ (oauthToken) in
        print("loginWithKakaoAccount() success.")

        // Do something
        _ = oauthToken        
    }, onError: {error in
        print(error)
    })
    .disposed(by: disposeBag)

When a user consents, Kakao identifies the user through the user's Kakao Account cookie stored on the default web browser and then issues tokens through the OAuthToken class.

Advanced: Request reauthentication

You can request reauthentication regardless of a user's login status to enhance security. Set prompts to .LOGIN, and pass it when calling loginWithKakaoAccount(). Then, the login screen is prompted even though a user has already been logged in on the same web browser on the device.

Sample

UserApi.shared.loginWithKakaoAccount(prompts:[.Login]) {(oauthToken, error) in
    if let error = error {
        print(error)
    }
    else {
        print("loginWithKakaoAccount() success.")           
        
        // Do something
        _ = oauthToken
            
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.loginWithKakaoAccount(prompts: [.Login])
    .subscribe(onNext:{ (oauthToken) in
        print("loginWithKakaoAccount() success.")

        // Do something
        _ = oauthToken        
    }, onError: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Check token presence

To check if a user has obtained an access token through Kakao Login, call the hasToken() method in AuthApi. This API returns the presence of an access token or refresh token as a boolean type. However, note that the return value true does not guarantee that the user is in a logged-in state.

Sample

if (AuthApi.hasToken()) {
    UserApi.shared.accessTokenInfo { (_, error) in
        if let error = error {
            if let sdkError = error as? SdkError, sdkError.isInvalidTokenError() == true  {
                //Login is required.
            }
            else {
                //Handle other errors.
            }
        }
        else {
            //Succeeded in validating token (Token is refreshed if needed).
        }
    }
}
else {
    //Login is required.
}

// Class member property
let disposeBag = DisposeBag()
                    
if (AuthApi.hasToken()) {
    UserApi.shared.rx.accessTokenInfo()
        .subscribe(onSuccess:{ (_) in
            //Succeeded in validating token (Token is refreshed if needed).
        }, onFailure: {error in
            if let sdkError = error as? SdkError, sdkError.isInvalidTokenError() == true  {
                //Login is required.
            }
            else {
                //Handle other errors.
            }
        })
        .disposed(by: disposeBag)
}
else {
    //Login is required.
}

If the value false is returned, it means that a token does not exist. In this case, implement a process for a user to log in to issue a token. On the other hand, if the return value is true, you can validate the access token that the user has through the accessTokenInfo() method in UserApi, and then proceed as follows depending on the request result:

• If the request is successful, the access token information is returned,
  • Access token is valid, which means the user does not need to log in.
  • You can call the Kakao APIs with the access token.
• If an error occurs,
  • Access and refresh tokens are invalid, which means the user needs to log in.
  • You need to handle errors by referring to API Reference.

Logout

The Logout API deletes the access and refresh token issued through the login process to have a user log out. You need to call the logout() method in UserApi class.

Regardless of the result of the logout request, the iOS SDK deletes the access and refresh tokens and has the login session end.

Sample

UserApi.shared.logout {(error) in
    if let error = error {
        print(error)
    }
    else {
        print("logout() success.")
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.logout()
    .subscribe(onCompleted:{
        print("logout() success.")
    }, onError: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Unlink

The Unlink API unlinks a user's Kakao Account from a service app. Call the unlink() method defined in the UserApi class.

If the request is successful, the iOS SDK deletes the access and refresh tokens. As the issued tokens are deleted, the session between an app and a user is disconnected, and the user is logged out and unlinked from your app.

Sample

UserApi.shared.unlink {(error) in
    if let error = error {
        print(error)
    }
    else {
        print("unlink() success.")
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.unlink()
    .subscribe(onCompleted:{
        print("unlink() success.")
    }, onError: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Retrieve token information

You can simply check the validity of the access token and refresh token, instead of requesting user information. Call the accessTokenInfo() method in the UserApi.

Sample

// Retrieve the expiration time of the access token.
UserApi.shared.accessTokenInfo {(accessTokenInfo, error) in
    if let error = error {
        print(error)
    }
    else {
        print("accessTokenInfo() success.")

        // Do something
        _ = accessTokenInfo        
    }
}

// Class member property
let disposeBag = DisposeBag()

// Retrieve the expiration time of the access token.
UserApi.shared.rx.accessTokenInfo()
    .subscribe(onSuccess:{ (accessTokenInfo) in        
        print("accessTokenInfo() success.")

        // Do something
        _ = accessTokenInfo 
        
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

AccessTokenInfo

Retrieve user information Consent required

To retrieve the information of the user who is currently logged in, call me() method defined in the UserApi class through the shared object.

Sample

UserApi.shared.me() {(user, error) in
    if let error = error {
        print(error)
    }
    else {
        print("me() success.")
        
        // Do something
        _ = user
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.me()
    .subscribe (onSuccess:{ user in
        print("me() success.")
        
        // Do something
        _ = user        
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

The user information in response to this request is passed to the User class defined in KakaoSDKUser. For example, you can access user.id to retrieve Service user ID, user.kakaoAccount.profile for Kakao Account's profile information, user.kakaoAccount.email for email.

User

Ensure that you need to handle exceptions for the following cases in which you cannot get the user information:

• If you do not enable the consent item for some user information.
• If a user has not agreed to provide the user information to the third-party service.
• If a user has not provided the user information to Kakao.

Retrieve shipping address Consent required

This API enables you to retrieve shipping addresses saved in user's Kakao Account.

To retrieve shipping address,

• You must enable the 'Shipping information (shipping_address)' scope.
• Users must consent to the scope. If a user does not consent, you cannot get the user data even though you enabled the scope. If Kakao does not retain a user's shipping address, Kakao cannot provide the information to your service even when a user consents.

The shipping_address scope is inactivated by default. To set the scope to 'Optional consent', connect your app to a Biz Channel. If your service must get users' shipping addresses, set the scope to 'Required consent' by going through the Review for Provision of Personal Information provided by Kakao Sync and use the Provision after collecting information option.

To retrieve a user's shipping addresses, call the shippingAddresses() method defined in the UserApi class. You can also use the following parameters.

Parameter

Sample

UserApi.shared.shippingAddresses {(shippingAddress, error) in
    if let error = error {
        print(error)
    }
    else {
        print("shippingAddresses() success.")
        // Do something
        _ = shippingAddress
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.shippingAddresses()
    .subscribe(onSuccess:{ (shippingAddress) in
        print("shippingAddresses() success.")

        // Do something
        _ = shippingAddress               
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Return data

shippingAddresses() returns the UserShippingAddresses object.

UserShippingAddresses

ShippingAddress

Store user information

You can store or update additional user information into the user property keys that you designated in [My Application] > [User Properties].

Call the updateProfile() method defined in the UserApi class. You must pass the custom property keys and values that you want to upadate through properties in a key-value pair. For example, if you want to update a user's clothing size, set properties to ["clothing_size":"small"].

Parameter

Sample

UserApi.shared.updateProfile(properties: ["${CUSTOM_PROPERTY_KEY}":"${CUSTOM_PROPERTY_VALUE}"]) {(error) in
    if let error = error {
        print(error)
    }
    else {
        print("updateProfile() success.")
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.updateProfile(properties:["${CUSTOM_PROPERTY_KEY}":"${CUSTOM_PROPERTY_VALUE}"])
    .subscribe(onCompleted:{
        print("updateProfile() success.")  
    }, onError: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Request additional consent Consent required

You can request consent to access permission or specific personal information if the user has not agreed when the user logged in with Kakao. Before using this API, read Concepts > Request additional consent thoroughly for a better understanding.

To use this API,

1. Enable the consent items for the scopes you want to obtain additional consent.
2. Call the loginWithKakaoAccount() method defined in the UserApi class. Pass the scopes of user information you want to request additional consent through scopes as an array of strings.

Parameter

Sample

Here is an example of checking which scopes are required to get consent with the me() method and requesting additional consent by passing scopes when calling loginWithKakaoAccount().

UserApi.shared.me() { (user, error) in
    if let error = error {
        print(error)
    }
    else {
        
        if let user = user {            
            
            //Add the desired scope among the list of all scopes.
            var scopes = [String]()
            if (user.kakaoAccount?.profileNeedsAgreement == true) { scopes.append("profile") }
            if (user.kakaoAccount?.emailNeedsAgreement == true) { scopes.append("account_email") }
            if (user.kakaoAccount?.birthdayNeedsAgreement == true) { scopes.append("birthday") }
            if (user.kakaoAccount?.birthyearNeedsAgreement == true) { scopes.append("birthyear") }
            if (user.kakaoAccount?.genderNeedsAgreement == true) { scopes.append("gender") }
            if (user.kakaoAccount?.phoneNumberNeedsAgreement == true) { scopes.append("phone_number") }
            if (user.kakaoAccount?.ageRangeNeedsAgreement == true) { scopes.append("age_range") }
            if (user.kakaoAccount?.ciNeedsAgreement == true) { scopes.append("account_ci") }
            
            if scopes.count > 0 {
                // If OpenID Connect (OIDC) is enabled,
                // - When "openid" is added to `scopes`, OIDC is applied.
                // - When "openid" is not added to `scopes`, OAuth 2.0 is applied. 
                                                    
                // To use OIDC, add "openid" to `scopes`.
                // scopes.append("openid")
                
                // The tokens are refreshed for the designated scopes.
                UserApi.shared.loginWithKakaoAccount(scopes: scopes) { (_, error) in
                    if let error = error {
                        print(error)
                    }
                    else {
                        UserApi.shared.me() { (user, error) in
                            if let error = error {
                                print(error)
                            }
                            else {
                                print("me() success.")
                                
                                // Do something
                                _ = user
                            }
                        }
                    }
                }
            }
            else {
                print("Not need to get additional consent.")
            }
        }
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.me()
    .map({ (user) -> User in

        //Add the desired scope among the list of all scopes.
        var scopes = [String]()
        
        if (user.kakaoAccount?.profileNeedsAgreement == true) { scopes.append("profile") }
        if (user.kakaoAccount?.emailNeedsAgreement == true) { scopes.append("account_email") }
        if (user.kakaoAccount?.birthdayNeedsAgreement == true) { scopes.append("birthday") }
        if (user.kakaoAccount?.birthyearNeedsAgreement == true) { scopes.append("birthyear") }
        if (user.kakaoAccount?.genderNeedsAgreement == true) { scopes.append("gender") }
        if (user.kakaoAccount?.phoneNumberNeedsAgreement == true) { scopes.append("phone_number") }
        if (user.kakaoAccount?.ageRangeNeedsAgreement == true) { scopes.append("age_range") }
        if (user.kakaoAccount?.ciNeedsAgreement == true) { scopes.append("account_ci") }
        
        if (scopes.count > 0) {

            // If OpenID Connect (OIDC) is enabled,
            // - When "openid" is added to `scopes`, OIDC is applied.
            // - When "openid" is not added to `scopes`, OAuth 2.0 is applied. 
                                                
            // To use OIDC, add "openid" to `scopes`.
            // scopes.append("openid")

            throw SdkError(scopes:scopes)
        }
        else {
            return user
        }
    })
    .retry(when: Auth.shared.rx.incrementalAuthorizationRequired())
    .subscribe(onSuccess:{ ( user ) in
        print("me() success.")

        // Do something
        _ = user
        
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Return data

loginWithKakaoAccount() presents the Consent screen asking for consent to the requested scope. When a user chooses to provide the scope and selects [Accept and Continue] on the Consent screen, new tokens are issued, and the scope information is updated in the OAuthToken class.

Retrieve consent details

This API enables you to retrieve the detailed information of the scopes (consent items) that a user has agreed to. You can check all scopes set in [My Application] > [Kakao Login] > [Consent Items] and the details of the scopes. If a user has consented to the scope before, the scope is included in the response even though your app is currently not using the scope.

Call the scopes() method in the UserApi class.

Parameter

Sample

UserApi.shared.scopes() { (scopeInfo, error) in
    if let error = error {
        self?.errorHandler(error: error)
    }
    else {
        self?.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.scopes()
    .subscribe(onSuccess:{ (scopeInfo) in
        self.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
                                    
    }, onFailure: {error in
        self.errorHandler(error: error)
    })
    .disposed(by: self.disposeBag)

You can also retrieve the information of specific scopes by passing scope IDs. In this case, the response includes only the detailed information of the specified scopes if the request is successful.

UserApi.shared.scopes(scopes: ["account_email","gender"]) { (scopeInfo, error) in
    if let error = error {
        self?.errorHandler(error: error)
    }
    else {
        self?.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.scopes(scopes: ["account_email","gender"])
    .subscribe(onSuccess:{ (scopeInfo) in
        self.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
                                    
    }, onFailure: {error in
        self.errorHandler(error: error)
    })
    .disposed(by: self.disposeBag)

Return data

If the request is successful, scopes() returns the ScopeInfo object that includes the details of each scope and whether a user has agreed to the scope.

ScopeInfo

scope

Revoke consent

This API revokes the scope that a user has agreed to. Call the revokeScopes() method in the UserApi class.

Parameter

Sample

UserApi.shared.revokeScopes(scopes: ["account_email","gender"]) { (scopeInfo, error) in
    if let error = error {
        self?.errorHandler(error: error)
    }
    else {
        self?.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.revokeScopes(scopes: ["account_email","gender"])
    .subscribe(onSuccess:{ (scopeInfo) in
        self.success(scopeInfo)
        
        // Do something
        _ = scopeInfo
                                    
    }, onFailure: {error in
        self.errorHandler(error: error)
    })
    .disposed(by: self.disposeBag)

Return data

If the request is successful, scopes() returns the ScopeInfo object that includes the details of each scope and whether a user has agreed to the scope.

Check user agreed terms

To check which terms a user has consented to when the user logs in, call the serviceTerms() method defined in the UserApi class.

Parameter

Sample

UserApi.shared.serviceTerms {(serviceTerms, error) in
    if let error = error {
        print(error)
    }
    else {
        print("serviceTerms() success.")
        // Do something
        _ = serviceTerms
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.serviceTerms()
    .subscribe(onSuccess:{ (serviceTerms) in
        print("serviceTerms() success.")
        
        // Do something
        _ = serviceTerms
        
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

Return data

serviceTerms() returns the UserServiceTerms object.

UserServiceTerms

AppServiceTerms

ServiceTerms

Return data

If the request succeeds, the response returns through the UserServiceTerms object that contains a service user ID and allowedServiceTerms, the terms the user has consented to. allowedServiceTerms is the list of the ServiceTerms object that provides the consented time and the term's tag.

For more details of ServiceTerms, refer to API Reference and the response of Web.

Get consent to desired terms

This API enables you to request consent to a specific term that a user has not consented, regardless of whether the user has already signed up or not.

If your app is used for multiple services and each service requires consent to different terms, or if a new required term is added to your service, you can use this API. For more details, Design terms and policies.

To request consent to specific scopes from a user, pass the list of term tags through serviceTerms as an argument when you call loginWithKakaoTalk() or loginWithKakaoAccount().

If you do not add serviceTerms when requesting an authorization code, the general Kakao Login API proceeds. In this case, you cannot request consent to the desired terms. Also, if a user has already consented to all required terms, the user is logged in without the Consent screen prompted. For more details, refer to FAQ.

Parameter

Sample

// Add service_terms in a string format that includes all terms separated by ‘,’
// ex) "tag1,tag2"
let serviceTerms = ["tag1", "tag2"]

UserApi.shared.loginWithKakaoAccount(serviceTerms: serviceTerms, completion: {(oauthToken, error) in
if let error = error {
        print(error)
    }
    else {
        print("loginWithKakaoAccount(serviceTerms:) success.")        
        // Do something
        _ = oauthToken
    }
})

// Class member property
let disposeBag = DisposeBag()

// Add service_terms in a string format that includes all terms separated by ‘,’
//  ex) "tag1,tag2"
let serviceTerms = ["tag1", "tag2"]

UserApi.shared.rx.loginWithKakaoAccount(serviceTerms: serviceTerms)
    .subscribe(onNext: { (oauthToken) in
        print("loginWithKakaoAccount(serviceTerms:) success.")        
        // Do something
        _ = oauthToken
    }, onError: {error in
        print(error)
    })
.disposed(by: disposeBag)

The response is returned through the OAuthToken object in the same as the Kakao Login.

Advanced: Manual signup

The Manual signup API manually links a user with your app to complete signup when the Auto-link is disabled.

To figure out if the currently logged-in user needs to be linked with your app, check the value of hasSignedUp in the response of the Retrieving user information API and handle each case:

• true: The user is already linked with your app. You do not need to call the Manual signup API.
• false: The user is not linked with your app. You must call signup() to link the user with your app manually.
• nil: Your app is using the Auto-link feature. You do not need to call the Manual signup API.

If the return value of hasSignedUp is false and the user is ready to sign up, call the signup() method to complete the signup.

Parameter

Sample

UserApi.shared.signup { (userId, error) in
    if let error = error {
        print(error)
    }
    else {
        print("signup() success.")
    }
}

// Class member property
let disposeBag = DisposeBag()

UserApi.shared.rx.signup()
    .subscribe (onSuccess:{ (userId) in
        print("signup() success.")        
    }, onFailure: {error in
        print(error)
    })
    .disposed(by: disposeBag)

If the request is successful, the user's service ID is returned.

To check the request result, request the Retrieving user information API again and check the value of hasSignedUp since the user's linked status is not provided even when the request is successful.

See more

• Download iOS SDK
• API Reference for iOS →
• API Reference for ReactiveX iOS →

Legacy

To see how to integrate Kakao Login using the Legacy Kakao SDK for iOS, see Kakao Login guide for Legacy iOS SDK.

It is highly recommended to migrate to the new version of iOS SDK as soon as possible because the Legacy version may not be supported anymore.