# Release notes

# LIFF version and release date

Beginning with LIFF v2.2.0, LIFF will follow Semantic Versioning (opens new window) (SemVer). For more information, see LIFF versioning policy.

CDN path

We provide two CDN paths: fixed and edge. If you use the CDN edge path, you are always up-to-date with the latest MINOR and PATCH updates. If you use the CDN fixed path, you need to manually update your URL with each update.

For more information, see LIFF SDK (sdk.js) update policy in the LIFF versioning policy documentation.

# Current version

When you use the CDN edge path (https://static.line-scdn.net/liff/edge/2/sdk.js), you can always use the latest features of LIFF v2.

LIFF v2.4.1: September 24, 2020

# Version list

When you use the CDN fixed path (e.g. https://static.line-scdn.net/liff/edge/versions/2.4.1/sdk.js), you can use the features of the specified LIFF version.

2020/09/28

# We've released LIFF v2.3.3

This bug has been fixed in LIFF v2.3.3:

There are no feature updates in this release.

# Fixed a bug that redirects users to unintended URLs when the endpoint URL ends with /

Under these conditions, accessing a LIFF URL causes a redirect to an unintended URL with a double path separator (//).

  • The URL specified in Endpoint URL contains a path and ends in /. Example: https://example.com/campaign/
  • Methods for converting additional information in the LIFF URL is set to Concatenate.
  • The LIFF URL contains a path (/path). Example: https://liff.line.me/{liffId}/path

In LIFF v2.3.3, the bug has been fixed so that the user is redirected to the correct URL even under the above conditions.

Item LIFF URL Primary redirect URL Secondary redirect URL
Before spec change https://liff.line.me/{liffId}/path https://example.com/campaign/?liff.state={urlEncode(/path)} https://example.com/campaign//path
After spec change https://liff.line.me/{liffId}/path https://example.com/campaign?liff.state={urlEncode(path)} https://example.com/campaign/path
Impact on other versions
  • If you are using LIFF v2.3.x, we recommend that you update to this patch version.
  • This bug has already been fixed in LIFF v2.4.1.

For more information on what happens when accessing LIFF URLs, see Operation from accessing LIFF URL to opening LIFF App in the LIFF documentation.

2020/09/24

# We've released LIFF v2.4.1

The changes are as follows:

# Fixed an issue with the feature to open another LIFF app without closing a LIFF app

We've found that the feature to open another LIFF app without closing the LIFF app, which we announced on August 31, 2020, has a bug and didn't work correctly even if the operating conditions were met.

In LIFF v2.4.1, the operating conditions have been changed as follows and the bug has been fixed.

Items Before the changes After the changes
LIFF SDK 2.4.0 2.4.1
LINE 10.16.0 10.18.0
The use of LIFF v2.4.0 is no longer recommended

Due to the above bug, the use of LIFF v2.4.0 is no longer recommended. If you are using LIFF v2.4.0, we recommend that you update to v2.4.1.

For more information, see Opening a LIFF app from another LIFF app in the LIFF document.

# Added a feature to liff.isApiAvailable() to check whether the transition between LIFF apps is possible

liff.isApiAvailable(), a method which checks if an API is available, can now be used to check if transitioning between LIFF apps is possible.

You can now execute liff.isApiAvailable('multipleLiffTransition') to confirm whether transitioning between LIFF apps is possible before opening another LIFF app. By using this feature, you can prevent an error when opening another app.

if (liff.isApiAvailable('multipleLiffTransition')) {
  window.location.href = "https://line.me/{liffId}", // URL for another LIFF app
}
Get information about transitioning between LIFF apps with liff.getContext()

You can now also use liff.getContext(), a method which obtains information about a LIFF app, to obtain information such as whether transitioning between LIFF app is possible, and the executable LINE version.

  • availability.multipleLiffTransition.permission: Indicates whether transitioning between LIFF apps is possible.
  • availability.multipleLiffTransition.minVer: Indicates the minimum LINE version that supports the transition between LIFF apps.

Below is an example of the return value of liff.getContext().

{
    "type": "utou",
    "utouId": "UU29e6eb36812f484fd275d41b5af4e760926c516d8c9faa35…b1e8de8fbb6ecb263ee8724e48118565e3368d39778fe648d",
    "userId": "U70e153189a29f1188b045366285346bc",
    "viewType": "full",
    "accessTokenHash": "ArIXhlwQMAZyW7SDHm7L2g",
    "availability": {
        "shareTargetPicker": {
            "permission": true,
            "minVer": "10.3.0"
        },
        "multipleLiffTransition": {
            "permission": true,
            "minVer": "10.18.0"
        }
    }
}

For more information, see liff.isApiAvailable() or liff.getContext() in the LIFF API reference.

# Fixed behavior of liff.init() being called twice

If you execute liff.init() more than once under the condition that the LIFF App is successfully initialized, a rejected Promise object was returned with an error message.

In LIFF v2.4.1, the error has been fixed so that if you execute liff.init() more than once under the condition that liff.init() succeeds, a resolved Promise object will be returned, and a warning message will be displayed.

For more information on initializing your LIFF App, see the LIFF document Initializing LIFF App.

2020/09/14

# We've released LIFF v2.3.2

The changes are as follows:

# Fixed error in which the URL fragment entered in the LIFF endpoint URL was not correctly handled by liff.permanentLink.createUrl()

When the LIFF endpoint URL contained a URL fragment (#URL-fragment), despite the Methods for converting additional information in the LIFF URL being set to Replace (Backward compatibility mode), the URL fragment was included in the permanent link returned after executing liff.permanentLink.createUrl().

Conditions under which this problem occurs
  • A URL fragment is included in the LIFF endpoint URL
  • Methods for converting additional information in the LIFF URL is set to Replace (Backward compatibility mode)

For example, when the Endpoint URL is set to https://example.com/path#section and liff.permanentLink.createUrl() is executed, https://liff.line.me/{liffId}/path?liff.state=#section would be returned as the permanent link. In LIFF v.2.3.2, the bug is fixed so that https://liff.line.me/{liffId} would be correctly returned.

# Fixed error in which the query parameter entered in the LIFF endpoint URL was not correctly handled by liff.permanentLink.createUrl()

When the LIFF endpoint URL contained a query parameter (?key=value), the query parameter would infinitely multiply in the permanent link returned after executing liff.permanentLink.createUrl().

Conditions under which this problem occurs
  • The query parameter in the LIFF endpoint URL matches the query parameter in the LIFF URL when executing liff.permanentLink.createUrl().
  • Methods for converting additional information in the LIFF URL is set to Concatenate

For example, when the Endpoint URL is set to https://example.com/path1/?q1=v1&q2=v2 and liff.permanentLink.createUrl() is executed in https://liff.line.me/{liffid}/?q1=v1&q2=v2, a permanent link with the query parameter infinitely multiplied such as https://liff.line.me/{liffid}/?q1=v1&q1=v1&q2=v2&q2=v2 would be returned.

In LIFF v.2.3.2, the bug is fixed so that https://liff.line.me/{liffid}/?q1=v1&q2=v2 would be correctly returned.

# Fixed error in which the path entered in the LIFF Endpoint URL was not correctly handled by liff.permanentLink.createUrl()

When path is included in the LIFF endpoint URL and a slash (/) is used at the end of the path, the permanent link obtained by executing liff.permanentLink.createUrl() would redirect you to URL without the ending slash as shown below.

Conditions under which this problem occurs
  • Path (/path/) is included in the LIFF endpoint URL, and a slash (/) is used at the end of the path
  • Query parameter (?key=value) or URL fragment (#URL-fragment) is included in the LIFF endpoint URL
  • Methods for converting additional information in the LIFF URL is set to Concatenate

For example, if Endpoint URL is set tohttps://example.com/path/?id=xxxxxxx, accessing a permanent link obtained by executing liff.permanentLink.createUrl() would redirect you to a URL without the ending slash, such as https://example.com/path?id=xxxxxxx.

In LIFF v2.3.2, the error has been fixed so that you are correctly redirected to https://example.com/path/?id=xxxxxxx.

# Fixed error in which fragment was not included in the secondary redirect URL

When a fragment was included in the LIFF endpoint URL or LIFF URL, regardless of settings based on Methods for converting additional information in the LIFF URL, the secondary redirect URL would not include a fragment. This error has been fixed.

For more details on the secondary redirect URL or how it is affected by settings based on Methods for converting additional information in the LIFF URL, see the LIFF document Operation from accessing LIFF URL to opening LIFF App.

# Fixed bug in which LIFF URLs were redirected to unintended URLs

In the primary redirect destination URL, additional information specified in the LIFF URL (ex:path/?key=value) is included in the liff.state query parameter. When additional information was included in the liff.state query parameter, there was bug in which you were redirected to unintended URLs as shown below.

Conditions under which this problem occurs
  • There is no / at the beginning of the liff.state query parameter
  • Methods for converting additional information in the LIFF URL is set to Replace (Backward compatibility mode)

For example, when Endpoint URL is set to https://example.com, and the liff.state query parameter was path, the domain name and path would not be separated by /, resulting in being redirected to https://example.compath.
In v2.3.2, the bug has been fixed so that you are correctly redirected to https://example.com/path.

Regarding vulnerability caused by unintended redirects

There is a possibility that users are redirected to malicious websites due to this bug. If you are using a LIFF SDK version before v2.4.0, we recommend that you update it.

For more information on what happens when accessing LIFF URLs, see the LIFF document Operation from accessing LIFF URL to opening LIFF App.

2020/09/14

# We've released LIFF v2.2.1

The change is as follows:

In the primary redirect destination URL, additional information specified in the LIFF URL (ex:path/?key=value) is included in the liff.state query parameter. When additional information was included in the liff.state query parameter, there was bug in which you were redirected to unintended URLs as shown below.

Conditions under which this problem occurs
  • There is no / at the beginning of the liff.state query parameter
  • Methods for converting additional information in the LIFF URL is set to Replace (Backward compatibility mode)

For example, when Endpoint URL is set to https://example.com, and the liff.state query parameter was path, the domain name and path would not be separated by /, resulting in being redirected to https://example.compath.
In v2.2.1, the bug has been fixed so that you are correctly redirected to https://example.com/path.

Regarding vulnerability caused by unintended redirects

There is a possibility that users are redirected to malicious websites due to this bug. If you are using a LIFF SDK version before v2.4.0, we recommend that you update it.

For more information on what happens when accessing LIFF URLs, see the LIFF document Operation from accessing LIFF URL to opening LIFF App.

2020/09/14

# We've released LIFF v2.1.14

The change is as follows:

In the primary redirect destination URL, additional information specified in the LIFF URL (ex:path/?key=value) is included in the liff.state query parameter. When additional information was included in the liff.state query parameter, there was bug in which you were redirected to unintended URLs as shown below.

Conditions under which this problem occurs
  • There is no / at the beginning of the liff.state query parameter
  • Methods for converting additional information in the LIFF URL is set to Replace (Backward compatibility mode)

For example, when Endpoint URL is set to https://example.com, and the liff.state query parameter was path, the domain name and path would not be separated by /, resulting in being redirected to https://example.compath.
In v2.1.14, the bug has been fixed so that you are correctly redirected to https://example.com/path.

Regarding vulnerability caused by unintended redirects

There is a possibility that users are redirected to malicious websites due to this bug. If you are using a LIFF SDK version before v2.4.0, we recommend that you update it.

For more information on what happens when accessing LIFF URLs, see the LIFF document Operation from accessing LIFF URL to opening LIFF App.

2020/08/31

# We've now released LIFF v2.4.0

Added on September 24, 2020

The use of LIFF v2.4.0 is no longer recommended due to a bug in the transition to another LIFF app without closing your current LIFF app feature.

Items Before the changes After the changes
LIFF SDK 2.4.0 2.4.1
LINE 10.16.0 10.18.0

If you are using LIFF v2.4.0, we recommend that you update to v2.4.1.

The changes in LIFF v2.4.0 are as follows:

# You can now use liff.closeWindow() before the LIFF app is initialized

You can now use the liff.closeWindow() method before the initialization of the LIFF app by liff.init() has finished.

Condition to execute the liff.closeWindow() method before initializing the LIFF app

To use the liff.closeWindow() method before the initialization of the LIFF app by liff.init() has finished, your LIFF SDK version must be v2.4.0 or later, and the user's LINE version must be 10.15.0 or later.

You can close the LIFF app with the liff.closeWindow() method if the LIFF app fails to initialize due to a network error, the user's LINE version, etc., as shown below.

liff
  .init({
    liffId: "123456-abcedfg" // Use own liffId
  })
  .then(() => {
    // Start to use liff's api
  })
  .catch((err) => {
    // Error happens during initialization
    console.log(err.code, err.message);
    liff.closeWindow();
  });

For more information, see liff.closeWindow() in the LIFF API Reference.

# You can now transition to another LIFF app without closing your current LIFF app

If you click the link to another LIFF app within a LIFF app whose screen is on Full display, you can display the other app while still having the LIFF browser open.
The LIFF browser doesn't close, so you can return to the original LIFF app with the return button from the LIFF browser.

Conditions for moving to another LIFF app without closing the current LIFF app (added on September 24, 2020)

There was a bug in LIFF v2.4.0 that prevented the feature from working properly. These changes have been made to the operating conditions for this feature:

  • LIFF SDK v2.4.1 or later and LINE 10.18.0 or later
  • The original LIFF app screen is set to Full display
  • The LIFF app to which you are moving is correctly initialized by liff.init()

LIFF-apps-transition

For more information, see Opening a LIFF app from another LIFF app in the LIFF Document.

# The error that LIFF URLs are redirected to unexpected URLs was fixed

An additional information (path/?key=value) specified in a LIFF URL is included in the liff.state query parameter for the primary redirected URL. When the liff.state query parameter contains an additional information, it might be redirected to an unexpected secondary redirected URL as follows.

Conditions that cause this error
  • When the liff.state query parameter doesn't begin with /
  • When setting Methods for converting additional information in the LIFF URL to Replace (Backward compatibility mode)

For example, if Endpoint URL is set to https://example.com and the liff.state query parameter is assigned to path, it was redirected to https://example.compath because the domain name and the path were not separated by /.
In the LIFF v2.4.0, this error has been fixed so that the URL above is now correctly redirected to https://example.com/path.

For more information on behaviors when accessing a LIFF URL, see Behaviors from accessing the LIFF URL to opening the LIFF app.

# liff.permanentLink.createUrl() error was fixed

When information, such as query parameter (?key=value) or URL fragment (#URL-fragment), was included in the LIFF endpoint URL, on occasion, the additional information section was not accurately reflected in the permanent link when liff.permanentLink.createUrl() was executed. This error has been fixed.

# The error of fragment not being included in the secondary redirct URL was fixed

When a fragment was included in the LIFF endpoint URL or LIFF URL, regardless of settings based on Methods for converting additional information in the LIFF URL, the secondary redirect URL would not include a fragment. This error has been fixed.

For more details on the secondary redirect URL or how it is affected by settings based on Methods for converting additional information in the LIFF URL, see the LIFF document Operation from accessing LIFF URL to opening LIFF App.

2020/07/16

# We've released LIFF v2.3.1

The changes in LIFF v2.3.1 are as follows:

There are no feature updates in this release.

# Problems with the LIFF SDK npm package documentation were fixed

We fixed an issue with the npm official site documentation (opens new window) for the LIFF SDK npm package that was experimentally released.

# Installation and usage instructions of the LIFF SDK npm package were moved

We moved the installation and usage instructions of the LIFF SDK npm package from the npm official website (opens new window) to the LINE Developers site. For more information, see Use the npm package.

2020/07/15

# New feature has been added to the LIFF header

As announced on July 6, 2020, a new feature has been added to the LIFF header.

LIFF header design to be improved

# The LIFF app icon is no longer displayed

The icon in the upper left corner of the LIFF app is no longer displayed.

# The share button has been added

LIFF apps with the size of the LIFF app view set to Full include a share button in the header. When a user taps the share button, the following options appear:

Item Description
Share Shares the URL of the current page via a LINE message.
Refresh Reloads the current page.

Enable Module mode of the LIFF app in the LINE Developers Console to hide the share button.

Operating environment

The share button will be available on LINE versions 10.12.0 or later for iOS and Android.

2020/07/01

# LIFF SDK released as an npm package

Until now, to include the LIFF SDK in a LIFF app, it was necessary to Specify the CDN path.

On July 1, 2020, we released the LIFF SDK npm package on a trial basis. Now you can use npm and Yarn to install the LIFF SDK.

For more information on the LIFF SDK npm package, see https://www.npmjs.com/package/@line/liff (opens new window).

The available LIFF SDK versions as an npm package is v2.3.0 or later. The features of future LIFF SDK versions will be announced on this page.

npm package trial

The npm package is available on a trial basis. It may be changed or deleted in the future without notice.

2020/06/29

# We've released LIFF v2.3.0

This feature has been added in LIFF v2.3.0:

# You can now use paths and query parameters in the LIFF endpoint URL

You can now use paths (/path) and query parameters (?key=value) added to the LIFF endpoint URL in the LIFF tab of the LINE Developers Console.

If setting Methods for converting additional information in the LIFF URL to Concatenate in LIFF apps, the access to the LIFF app is redirected to the URL that combines Endpoint URL including the paths and query parameters, and additional information set to LIFF URL.

For more information, see Opening a LIFF app in the LIFF documentation.

When executing the liff.permanentLink.createUrl() method, an exception is thrown if the current page URL doesn't start with the URL specified in Endpoint URL.

Especially when setting Methods for converting additional information in the LIFF URL to Replace (Backward compatibility mode), the paths and query parameters (/2020campaign/?key=value) specified in Endpoint URL may not be included in the secondary redirect URL. In this case, you can't get a permanent link because the liff.permanentLink.createUrl() method meets the above conditions.

For more information, see liff.permanentLink.createUrl() in the LIFF v2 API reference.

# You can now get the send results of liff.shareTargetPicker()

Before the spec change, the LIFF app was able to confirm whether the target picker was displayed, but not whether the message was sent after that.

After the change, the LIFF app is able to check whether the message has been sent, so you can change the behavior of the LIFF app depending on the user's situation.

Note
  • The return value of liff.shareTargetPicker() is changed due to this spec change.
  • This spec change doesn't affect users using LINE 10.3.0 - 10.10.0.

For more information, see liff.shareTargetPicker() in the LIFF v2 API reference.

# An error code returned by liff.sendMessages() added

Previously, if passing the wrong parameters to liff.sendMessages(), 400 was returned as the error code of LiffError. After the spec change, INVALID_ARGUMENT is returned instead.

As long as the processing isn't split by error codes, this spec change doesn't effect your LIFF app.

For more information, see our News coverage for June 29, 2020.

2020/06/15

# LIFF v2.2.0: LIFF error codes added

The LiffError codes passed when Promise is rejected in the following methods have been made more detailed, making the cause of the problem easier to understand.

For more information, view the Error Response descriptions for these methods:

2020/04/30

# LIFF v2.1.13: liff.getLineVersion() and liff.id added to LIFF v2

We added the liff.getLineVersion() method and the liff.id property to LIFF v2.

liff.getLineVersion() allows you to get the user's LINE version.

If a user opens the LIFF app using LIFF browser, the LINE version of the user is returned as a string. If a user opens the LIFF app using an external browser, null is returned.

liff.id is the property that holds the LIFF app ID (String type) passed to liff.init().

Learn more about liff.getLineVersion() and liff.id in the LIFF v2 API reference.

2020/04/03

# liff.isApiAvailable() added to LIFF v2

We added the method liff.isApiAvailable() to LIFF v2. This method checks whether a specified API can be used in the environment where the LIFF app was launched.

Note

The number of APIs you can specify is limited. Currently, you can only specify liff.shareTargetPicker(). We'll notify you when more APIs can be checked with liff.isApiAvailable() in the future.

# Check if share target picker is available

By executing liff.isApiAvailable() before you execute liff.shareTargetPicker(), you can avoid the user getting an error message on their screen if the share target picker isn't available in their device environment.

if (liff.isApiAvailable('shareTargetPicker')) {
  liff.shareTargetPicker([
    {
      type: "text",
      text: "Hello, World!"
    }
  ])
    .then(
      alert("ShareTargetPicker was launched")
    ).catch(function(res) {
      alert("Failed to launch ShareTargetPicker")
    })
}

Learn more from liff.isApiAvailable() in the LIFF v2 API reference.

2020/03/03

# liff.shareTargetPicker() and liff.ready added to LIFF v2

We added liff.shareTargetPicker() and liff.ready to LIFF v2.

# liff.shareTargetPicker()

Execute the liff.shareTargetPicker() method to display the target picker (screen for selecting a group or friend) and send the message created by the developer to the selected target. This message appears to your group or friends as if you had sent it.

target picker

For more information, see Sending messages to a user's friend (share target picker) in the LIFF documentation.

Target picker operating environment

Target picker is supported on 10.3.0 for both LINE for iOS and LINE for Android.

# liff.ready

With liff.ready, you can get the Promise object that resolves when you run liff.init() for the first time after starting the LIFF app. If you use liff.ready, you can execute any process after the completion of liff.init().

For more information, see liff.ready in the LIFF v2 API reference.

2020/02/07

# Notice about LIFF v1 APIs and discontinuation schedule change

We announced that the end-of-life of LINE Front-end Framework (LIFF) server API was scheduled for March 31, 2020. Due to feedback received, we will continue to provide the API.

As for LIFF v1, we will announce the discontinuation schedule as soon as it is decided. In the meantime, we recommend that you migrate from v1 to v2 as soon as possible.

Feature Schedule before this update Schedule after this update
LIFF v1 Client API Scheduled for discontinuation Scheduled for discontinuation (This has not changed)
LIFF v1 Server API Scheduled for discontinuation on March 31, 2020 Support continues
LIFF v1 will still be discontinued

As announced on October 16, 2019, LIFF v1 will be discontinued. Use the latest version of LIFF.

2020/02/05

# Users can no longer add LIFF apps to Messaging API channels

As announced on November 11, 2019, due to a function enhancement with LIFF v2, users can no longer add LIFF apps to Messaging API channels.

To find out about restrictions on LIFF apps already added to the Messaging API channel, and how to transition to the LINE Login channel, see the above news article.

2020/01/21

# LIFF v1 Server API end-of-life on March 31, 2020

March 31, 2020 marks the end-of-life date for LINE Front-end Framework (LIFF) v1 Server API. On that date, these features will be removed:

Use the latest version of LIFF

As announced on October 16, 2019, LIFF v1 will be discontinued.

# Use LIFF v2

All discontinued Server API functions can be used in the LINE Developers Console. For more information on how to add a LIFF app to a channel, read this:

You can use other features with the same process.

LINE will continue to improve the quality of its services. Thank you for your understanding.

2020/01/14

# Update your code that uses the suspended LIFF SDK API

As announced on November 29, 2019, on LINE for iOS 9.19.0 or later, these APIs were temporarily suspended due to technical issues.

  • liff.scanCode()
  • liff.bluetooth.*

Starting today, for end users using the LIFF app on LINE 9.19.0 or later for iOS, each API works as follows.

API Function
liff.scanCode() API is undefined
liff.bluetooth.* If the Bluetooth plug-in fails to initialize when calling liff.initPlugins(['bluetooth']), a FORBIDDEN error is returned.

If you use liff.scanCode(), we recommend that you also consider the above case and verify that the function exists.

Before modification:

liff.scanCode().then(result => {
  // result = { value: '' }
});

Modified:

if (liff.scanCode) {
	liff.scanCode().then(result => {
	  // result = { value: '' }
	});
}

For more information, see LIFF v2 API reference.

LINE will continue to improve the quality of its services. Thank you for your understanding.

2019/11/29

# Some LIFF functions suspended

Due to a technical issue, we've temporarily suspended the following LIFF functions. We'll let you know as soon as this situation changes.

  • liff.scanCode()
  • liff.bluetooth.*

# Impacted environments

Environment Version
LINE for iOS On version 9.19.0 and later, the functions listed above are temporarily unavailable.
LINE for Android Not affected for now, but more news will follow soon.

We apologize for the inconvenience and are working hard to solve the problem.

2019/11/11

# Users can no longer add LIFF apps to Messaging API channels

LIFF v2 is scheduled to be updated with LINE Login as the core channel. Additionally, an upcoming change will prevent users from adding LIFF apps to Messaging API channels entirely. We strongly recommend users to add LIFF apps to the LINE Login channel.

# Scheduled change date

Early February 2020

# Influence

Channel type Impact
LINE Login channel Not affected.
Messaging API channel After the specification change, LIFF apps cannot be added to the Messaging API channel. LIFF apps added to Messaging API channels at the time of specification change are still usable.
Do not add LIFF apps to the Messaging API channel

At this time, users can add LIFF apps to the Messaging API channel. However, we strongly advise against it due to the following restrictions:

  • The bot link feature can't be used.
  • LIFF feature expansion may not be supported.
  • The LIFF app may not be usable in the future.

LIFF apps added to the LINE Login channel have no restrictions and can use all LIFF v2 functions.

# Transition to the LINE Login channel

To continue using the LIFF app added to the Messaging API channel, re-add the LIFF app to the LINE Login channel. Once re-added, LINE Developers Console will issue a new LIFF app ID. As a result, please take note of the following:

  • If you're using LIFF v2, change the LIFF app ID specified in liff.init().
  • The LIFF URL used to launch LIFF (e.g.: line://app/1234567890-AbcdEfgh) will change.
Remove LIFF apps added to Messaging API channel

To avoid confusion, delete the LIFF app added to the Messaging API channel after adding to the LINE Login channel.

2019/10/16

# LIFF v2 released

LINE Front-end Framework (LIFF) v2 is a platform for web apps provided by LINE.

Use the latest version of LIFF

LIFF v1 will be deprecated.

# LIFF apps now run in external browsers

With LIFF v1, LIFF apps ran only in a LIFF browser. With LIFF v2, LIFF apps can also run in external browsers. This means you can develop LIFF apps using the same development environment as general web applications.

# Get user profile and email

Because compatibility with LINE Login v2.1 has improved, you can retrieve a user's ID and email address from the LINE platform. Your LIFF app can use this data to provide features related to user information and sending emails.

Furthermore, you can use LINE Login (web login flow) even when your LIFF app is running in an external browser. This means you can use the same information even when the LIFF app is running in an external browser.

# Read QR codes

You can start LINE's QR code reader and get the strings read by the user.

# Get LIFF app environment information

You can get the following details about the environment in which your LIFF app is running:

  • Operating system in which the LIFF app is running (iOS, Android, external browser)
  • Whether the LIFF app is running in the LIFF browser (true, false)
  • Language settings

For more information, see LINE Front-end Framework.

2019/04/23

We have improved the consent screen bundled with the LINE Front-end Framework (LIFF). The improvement is automatically applied to all LIFF apps. There's no need for additional development work.

New consent screen

As before this update, the user can choose to not allow the LIFF app to send messages to chats. But if they do so, unlike before, the consent screen will reappear the next time the user launches the LIFF app.

2019/02/07

# You can get access tokens through LIFF SDK

We added the liff.getAccessToken() method to the LIFF SDK.

Use the access token to interact with the Social API to access user data on the LINE Platform.

For more information, see Getting the user's access token.

2018/11/16

# Renewed LIFF server API

Now you can set the following properties to your LIFF apps.

  • description property
  • features.ble property

The API endpoint for updating a LIFF app is changed. Now you can partially update the properties of your LIFF apps.

For more information, see the following sections:

2018/10/30

# LIFF apps can now be added with the LINE Developers Console

Now you can add LIFF apps with the LINE Developers Console. As before, you can still add LIFF apps with the LIFF server API.

For more information, see Adding a LIFF app.

2018/07/19

# The maximum number of LIFF apps has been increased

Now you can add up to 30 LIFF apps for one channel. The previous maximum number was 10.

For more information, see Add LIFF app in the LIFF API reference documentation.

2018/06/06

# LINE Front-end Framework released

LINE Front-end Framework (LIFF) is a platform for web apps that run within LINE.

When launching a web app (LIFF app) registered in LIFF in LINE, the LIFF app can get data from the LINE Platform such as the LINE user ID. The LIFF app can use such data to provide features that utilize user information and send messages on behalf of the user.

For more information, see LINE Front-end Framework.