Skip to main content

Getting Started

A quick guide on how to easily get started with the VideoEditor SDK for Android. Your kick-off to delight your users with top-notch editing capabilities.

This document guides you through the process of integrating the VideoEditor SDK into your Android application.

Free Trial#

Our tech is modified to be used for testing purposes without a license key. To start testing just follow this Get Started guide and set the licensePath to null in your module's build.gradle file instead of entering the commercial license path. The editor will simply render a watermark over the preview and final results. And in case you need any technical assistance, make sure to reach out to us: We'll be glad to help.


The following software is required:

  • Mac OS X, Windows, or Linux
  • Android Studio 3.0+
  • Android Minimum SDK 21+ (Android 5.0+)
  • Gradle Plugin Version 3.5+
  • Gradle Version 6.1.1+
  • Android Build Tools 31.0.0+
  • AndroidX
  • Kotlin Version 1.5.32+
  • License*

*The license is required to commercially use our tech in your application. Yet while testing no license file is required. For more information please see the FREE TRIAL note further up on this guide.

Supported Android versions#

The VideoEditor SDK supports Android 5.0+ API 21 as the minSdkVersion, but it must be compiled with compileSdkVersion 31+.

Add your license file#

Before using any components of the VideoEditor SDK, you have to add your license file to your applications assets folder. The expected default name of the license file is “LICENSE”. In order to change this, see vesdk.licensePath option of imglyConfig in your build.gradle file. The license is digitally signed and can’t be altered without becoming invalid. Once the license file has been added the application will validate its presence upon launch.

Setting up the workspace#

Add the and Kotlin plugin to the buildscript classpath in your root build.gradle file. Make sure to also add the Maven repository:

buildscript {
repositories {
mavenCentral() // needed for kotlin-gradle-plugin
maven { url '' }
dependencies {
// Insert the latest SDK version number here. You can find it at
classpath ''
// Add the Kotlin plugin
classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.32'

Add the Maven repository in your root build.gradle file. Skip this step if you're using the dependencyResolutionManagement syntax in your project.

allprojects {
repositories {
maven { url '' }

If you're using the dependencyResolutionManagement syntax, add the Maven repository in the settings.gradle file at the root of your project:

dependencyResolutionManagement {
repositories {
maven { url '' }

Apply the plugin and add the imglyConfig block into your module's build.gradle file:

// Apply the Android Plugin
apply plugin: ''
// Apply the IMGLYPlugin
apply plugin: ''
// Apply Kotlin Plugin
apply plugin: 'kotlin-android'
// Configure the plugin
imglyConfig {
vesdk {
enabled true
licensePath 'vesdk_android_license' // set `null` for free trial
// Define the modules you are need
modules {
// Add all the UI modules you are need
include 'ui:video-trim'
include 'ui:core'
include 'ui:text'
include 'ui:focus'
include 'ui:frame'
include 'ui:brush'
include 'ui:filter'
include 'ui:sticker'
include 'ui:overlay'
include 'ui:transform'
include 'ui:adjustment'
include 'ui:text-design'
// Add the serializer if you need
include 'backend:serializer'
// Add asset packs if you need
include 'assets:font-basic'
include 'assets:frame-basic'
include 'assets:filter-basic'
include 'assets:overlay-basic'
include 'assets:sticker-shapes'
include 'assets:sticker-emoticons'
// Do your Android Configurations... ex.
android {
/* Set the compileSdkVersion at 31 or greater and set the buildToolsVersion at '31.0.0' or greater.
* We can't provide support for bugs, that are the result of older SDK versions.
compileSdkVersion 31
buildToolsVersion '31.0.0'
defaultConfig {
* Replace with your App-ID and keep sure that it match with your license!
* @see
applicationId "my.domain.application"
/* Set the minimum supported SDK Version to 21 (Android 5.0) or higher */
minSdkVersion 21
/* Set the target SDK Version at minimum to 29 or higher */
targetSdkVersion 29
/* Set Java Language level to Java 1.8+ */
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8

Sync your project with the Gradle files after every edit! For more information about Gradle, please take a look at the Android Developer Documentation


If you want to open the video editor look at this example:

class KVideoEditorDemoActivity : Activity() {
companion object {
const val VESDK_RESULT = 1
const val GALLERY_RESULT = 2
// Create an empty new SettingsList and apply the changes on this reference.
// If you include our asset Packs and use our UI you also need to add them to the UI Config,
// otherwise they are only available for the backend (like Serialisation)
// See the specific feature sections of our guides if you want to know how to add your own Assets.
private fun createVesdkSettingsList() =
.configure<UiConfigFilter> {
.configure<UiConfigText> {
.configure<UiConfigFrame> {
.configure<UiConfigOverlay> {
.configure<UiConfigSticker> {
.configure<VideoEditorSaveSettings> {
override fun onCreate(savedInstanceState: Bundle?) {
fun openSystemGalleryToSelectAVideo() {
val intent = Intent(Intent.ACTION_PICK)
intent.setDataAndType(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, "video/*")
try {
startActivityForResult(intent, GALLERY_RESULT)
} catch (ex: ActivityNotFoundException) {
"No Gallery APP installed",
fun openEditor(inputSource: Uri?) {
val settingsList = createVesdkSettingsList()
settingsList.configure<LoadSettings> {
it.source = inputSource
.startActivityForResult(this, VESDK_RESULT)
override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent) {
super.onActivityResult(requestCode, resultCode, intent)
if (resultCode == RESULT_OK && requestCode == GALLERY_RESULT) {
// Open Editor with some uri in this case with an video selected from the system gallery.
} else if (resultCode == RESULT_OK && requestCode == VESDK_RESULT) {
// Editor has saved an Video.
val data = EditorSDKResult(intent)
Log.i("VESDK", "Source video is located here ${data.sourceUri}")
Log.i("VESDK", "Result video is located here ${data.resultUri}")
// TODO: Do something with the result video
// OPTIONAL: read the latest state to save it as a serialisation
val lastState = data.settingsList
try {
} catch (e: IOException) {
} else if (resultCode == RESULT_CANCELED && requestCode == VESDK_RESULT) {
// Editor was canceled
val data = EditorSDKResult(intent)
val sourceURI = data.sourceUri
// TODO: Do something with the source...

Sample Application#

You can access the source code for our demo application from our demo repository.