KakaoTalk API

Every KakaoTalk integration starts at developers.kakao.com — this is where Kakao validates your app before allowing any API access. Sign in with your Kakao account and click 'My Application' in the top navigation, then 'Create Application'. Enter your app name, company name (can be your own), and upload an icon (required). Click Save. You'll land on the app's Overview page. Note the four keys shown: **Native App Key** (used in the Flutter SDK — safe to include in the app), **REST API Key** (used for server-side REST calls without user auth), **JavaScript Key** (for web), and **Admin Key** (full power — server-only, never in the app). Copy the Native App Key and REST API Key for later. Now add platform credentials. Click 'Platform' in the left sidebar. Under Android, click 'Register'. Enter your app's package name (the same one in your FlutterFlow project settings under App Details → Package Name, typically `com.yourcompany.yourapp`). You also need the **key hash** — this is an SHA-1 fingerprint of your signing keystore encoded in base64. For the debug keystore (used during FlutterFlow test builds), run this once in Terminal: `keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -storepass android -keypass android | openssl sha1 -binary | openssl base64` and paste the result. Add both your debug hash and release hash. Under iOS, click 'Register', enter your iOS bundle identifier (from FlutterFlow → App Details → iOS Bundle ID), and save. Without these exact values registered, Kakao Login rejects every attempt with a `KOE101` or `KOE102` error. Finally, in the left sidebar go to 'Kakao Login' under the Products section and toggle 'Activate Kakao Login' to On. Accept the consent terms. Check the 'Required Consent Items' — at minimum enable profile nickname and profile image so you can display the user's name after login.

In the FlutterFlow editor, click the Custom Code icon in the left navigation (angle-brackets `</>`). At the top of the Custom Code panel, click the Dependencies button. Click '+ Add Dependency' and search for `kakao_flutter_sdk_user`. This is the lightweight user/auth package from the official Kakao Flutter SDK — choose it over `kakao_flutter_sdk` (the full SDK) to keep your app binary smaller if you only need login and user profile. Enter the latest stable version from pub.dev/packages/kakao_flutter_sdk_user. As of mid-2026 it is in the 1.9.x range — always check pub.dev for the current version. Click Add. Wait for FlutterFlow to resolve the dependency (green checkmark). If you also need the Kakao Link (sharing) feature, add `kakao_flutter_sdk_share` as a second dependency. For Kakao Talk channel messages, add `kakao_flutter_sdk_talk`. Adding all three is fine; they share core SDK code. Next, you need to add the Kakao Native App Key to your app's platform configuration. In FlutterFlow, go to Settings & Integrations → App Settings. Under iOS, find the 'Custom Info.plist Entries' field and add: ``` <key>KAKAO_APP_KEY</key> <string>YOUR_NATIVE_APP_KEY</string> <key>LSApplicationQueriesSchemes</key> <array><string>kakaokompassauth</string><string>storykompassauth</string><string>kakaolink</string><string>kakaotalk</string></array> ``` For Android, FlutterFlow allows custom AndroidManifest entries under Settings & Integrations → App Settings → Android — add the `KAKAO_APP_KEY` meta-data element and the KakaoTalk scheme in a `<queries>` block. This platform configuration is required for the SDK to function — without it, the login flow fails before the Dart code even runs.

1<!-- Android AndroidManifest.xml additions (enter in FlutterFlow Android manifest settings) -->
2<meta-data
3    android:name="com.kakao.sdk.AppKey"
4    android:value="YOUR_NATIVE_APP_KEY" />
5
6<queries>
7  <package android:name="com.kakao.talk" />
8</queries>

In the Custom Code panel, click + Add → Action. Name it `kakaoLogin`. Set the Return Type to JSON — you'll return a structured object with the access token and basic user profile. Add no required parameters (credentials come from the Kakao console via the SDK, not from FlutterFlow parameters). The Kakao Flutter SDK offers two login methods: `UserApi.instance.loginWithKakaoTalk()` (opens the KakaoTalk app for auth — faster, preferred on devices with KakaoTalk installed) and `UserApi.instance.loginWithKakaoAccount()` (opens a WebView for browser-based login — used as fallback). The standard pattern is to try KakaoTalk first and fall back to the account web login. After successful login, call `UserApi.instance.me()` to retrieve the user's profile (Kakao ID, nickname, profile image URL). Return these along with the access token as a JSON map. Store the access token in a FlutterFlow App State String variable named `kakaoAccessToken`. This is the credential you'll pass to the Kakao REST API Calls as a Bearer token header. The access token is a short-lived credential (typically valid for hours) — refresh handling is managed by the Kakao SDK automatically on subsequent SDK calls. Important: this custom action will not run in FlutterFlow's web preview (Run mode). You must test on a physical Android or iOS device. When you click Run Mode in the FlutterFlow editor, the Kakao Login button will appear but nothing will happen — that's expected behavior for native SDK custom actions.

1// FlutterFlow Custom Action: kakaoLogin
2// Return type: JSON
3// No parameters needed — SDK uses platform config
4
5import 'package:kakao_flutter_sdk_user/kakao_flutter_sdk_user.dart';
6
7Future<dynamic> kakaoLogin() async {
8  // Initialize the SDK with your Native App Key
9  // (best done in main.dart via Custom Function, or here if not already done)
10  KakaoSdk.init(nativeAppKey: 'YOUR_NATIVE_APP_KEY');
11
12  try {
13    OAuthToken token;
14
15    // Try KakaoTalk app login first (fastest UX)
16    if (await isKakaoTalkInstalled()) {
17      token = await UserApi.instance.loginWithKakaoTalk();
18    } else {
19      // Fall back to web (Kakao Account) login
20      token = await UserApi.instance.loginWithKakaoAccount();
21    }
22
23    // Fetch user profile after login
24    final user = await UserApi.instance.me();
25    final profile = user.kakaoAccount?.profile;
26
27    return {
28      'success': true,
29      'accessToken': token.accessToken,
30      'userId': user.id.toString(),
31      'nickname': profile?.nickname ?? '',
32      'profileImageUrl': profile?.profileImageUrl ?? '',
33      'thumbnailImageUrl': profile?.thumbnailImageUrl ?? '',
34    };
35  } catch (e) {
36    return {
37      'success': false,
38      'error': e.toString(),
39      'accessToken': '',
40      'userId': '',
41      'nickname': '',
42      'profileImageUrl': '',
43      'thumbnailImageUrl': '',
44    };
45  }
46}

With the user access token stored in App State after login, you can now make Kakao REST API calls directly from FlutterFlow's API Calls panel — no more custom actions needed for most features. In the FlutterFlow editor, click API Calls in the left nav. Click + Add → Create API Group. Name it `KakaoApi`. Set the Base URL to `https://kapi.kakao.com`. In the Headers section of the API group, add a shared header: `Authorization` with value `Bearer [kakaoToken]`. Click the Variables tab and create a group-level variable named `kakaoToken` (String type). This shared header means every API Call you add to this group will automatically include the Bearer token — you only need to bind `kakaoToken` to the App State `kakaoAccessToken` variable once per action flow. Now add the first API Call inside the group. Click + Add → Create API Call. Name it `GetProfile`. Set Method to GET and Path to `/v2/user/me`. In the Response & Test tab, click 'Test API Call' — you'll need to manually enter a real access token from a previous login test to make this work. After a successful response, click 'Generate JSON Paths' to create shortcut paths: `$.id` (Kakao user ID), `$.kakao_account.profile.nickname`, and `$.kakao_account.profile.profile_image_url`. Add a second API Call named `SendMeMessage`. Set Method to POST and Path to `/v1/api/talk/memo/default/send`. Set Body Type to form fields (URL-encoded). Add a form field: `template_object` with value `[messageTemplate]`. Add a String variable `messageTemplate` to the Variables tab. The Kakao 'send to me' API accepts a JSON template object serialized as a string in the form body — a quirk of the Kakao API design. A minimal template looks like: `{"object_type":"text","text":"[your message]","link":{"web_url":"https://yourapp.com"}}`. Bind this API group in Action Flows: after the `kakaoLogin` custom action succeeds, store the `accessToken` JSON path result to App State `kakaoAccessToken`, then you can call `GetProfile` with `kakaoToken` bound to `kakaoAccessToken`.

1// Kakao API Call config reference
2{
3  "Group": "KakaoApi",
4  "Base URL": "https://kapi.kakao.com",
5  "Shared Headers": {
6    "Authorization": "Bearer [kakaoToken]"
7  },
8  "Group Variables": [
9    { "name": "kakaoToken", "type": "String" }
10  ],
11  "Calls": [
12    {
13      "name": "GetProfile",
14      "method": "GET",
15      "path": "/v2/user/me",
16      "json_paths": [
17        { "name": "userId",   "path": "$.id" },
18        { "name": "nickname", "path": "$.kakao_account.profile.nickname" },
19        { "name": "imageUrl", "path": "$.kakao_account.profile.profile_image_url" }
20      ]
21    },
22    {
23      "name": "SendMeMessage",
24      "method": "POST",
25      "path": "/v1/api/talk/memo/default/send",
26      "body_type": "Form URL Encoded",
27      "body_fields": {
28        "template_object": "[messageTemplate]"
29      },
30      "variables": [
31        { "name": "messageTemplate", "type": "String" }
32      ]
33    }
34  ]
35}

Create a Login screen in FlutterFlow with a Column containing a logo/title, a 'Login with KakaoTalk' Button (use Kakao's brand yellow #FEE500 with black text — Kakao branding guidelines require this), and optionally a skip or email login option. Select the Kakao Login button, open the Actions panel, and click + Add Action. Under Custom Actions, select `kakaoLogin`. Chain actions after `kakaoLogin` completes. First, add a Conditional action checking the JSON response path `$.success` (Boolean). If true: use a Set App State action to store `$.accessToken` into `kakaoAccessToken`, `$.nickname` into `kakaoNickname`, and `$.profileImageUrl` into `kakaoProfileImage`. Then navigate to your Home screen. If false: show a SnackBar with `$.error` from the response to help debug. On the Home screen, bind widgets to the App State: show the user's Kakao nickname in a Text widget and their profile image in a NetworkImage widget using the `kakaoProfileImage` URL. Add a 'Send Me a Test Message' button that calls the `SendMeMessage` API Call with a `template_object` value like `{"object_type":"text","text":"Hello from my FlutterFlow app!","link":{"web_url":"https://yourapp.com"}}` — a JSON string serialized as a form field value. To test: use FlutterFlow's Test Mode to install the app on a physical Android or iOS device. The device must have the KakaoTalk app installed for the SDK login to open it. If KakaoTalk isn't installed, the SDK falls back to the web-based Kakao Account login view. After login, verify the access token is populated in App State by checking the FlutterFlow Debug Panel. Send the test message and check your KakaoTalk 'My Inbox' (나와의 채팅) — it should appear within seconds.