6 Routes for Adding a Video Editing SDK to an iOS App and Where Each Breaks

A video editing SDK for iOS is a packaged framework that hands your app a timeline, effects and export so your team does not assemble them from AVFoundation primitives. Six routes are realistic on iOS today, and the right one depends on a single input: the list of things your editor must do on day one.

The routes fail at different points, from a portrait-only system view to a license that only arrives after a sales call. Banuba sells one of the SDKs compared below, the Banuba Video Editor SDK, and it gets the same treatment as the rest, including the jobs it cannot do and the toolchain it forces on your build machine.

Step 1: List what the editor has to do

Before comparing anything, collect four inputs.

• Your deployment floor and toolchain. The minimum iOS version you ship and the Xcode version your CI runs. One SDK below requires Xcode 26.0, which in turn requires a recent macOS, so check your build machines before your deployment target.
• Your feature tier. Sort the plan into one of four buckets: (a) trim, join and export; (b) a timeline UI with text, music and filters; (c) camera-time effects such as face masks, beauty or background replacement applied while recording; (d) the same editor on Android, in a browser or on a server.
• Your oldest supported device. Step 5 times exports on it.
• Who signs contracts. Two of the routes cannot be prototyped until someone talks to sales.

Tier (a) has two no-cost answers; tiers (b) to (d) are where licensed SDKs come in.

Step 2: Choose a video editing SDK route (or none)

Route	Product compared	Access and availability	iOS install path (per vendor docs)	App size added (vendor-published)	Trial (vendor terms)	Where it breaks
UIVideoEditorController	Apple's system trim view in UIKit	Free, first-party	Part of UIKit	Ships with iOS	Not applicable	Portrait only; no subclassing or overlay views
AVFoundation	Apple's media framework	Free, first-party	Part of the iOS SDK	Ships with iOS	Not applicable	No editor UI, no face AR, beauty, background removal or captions
Banuba Video Editor SDK	Native editor with UI plus Face AR	Open sample on GitHub; trial token on request, then license	CocoaPods 1.12.1+ or SPM; iOS 15.0+, Swift 5.9+, Xcode 26.0+	14 MB core, 45 MB full bundle	14 days, all features	Requires Xcode 26 on your build machines; no browser editor, no headless server render, no pro multi-track or HDR export
IMG.LY Video Editor SDK (CE.SDK)	Cross-platform editor engine	Sales-gated custom quote	CocoaPods, pod 'IMGLYUI'	Not published	30 days, full access	Each platform licensed separately; no face AR or beauty in documented features
Meishe StreamingSDK + EffectSDK	Pro editing and effects engine	Login-gated download, contact sales	Objective-C against NvsStreamingContext	Not published	Trial authorization, watermarked output	Per-app license file bound to bundle ID; media must be transcoded to its own m3u8
Picsart Editor SDK	Web editor embed	CDN script tag; no iOS package	None documented	Not applicable	Not evaluated	Desktop browsers only; WebView unsupported

Figures come from each vendor's own documentation as read in September 2026. Vendor pages change, so anything that decides a build (price, size, trial terms, license mechanics) should come from the vendor in writing.

UIVideoEditorController

Apple's system interface for trimming and re-encoding a recorded movie, free and first-party. The UIKit reference lists its limits: portrait mode only, no subclassing, a private view hierarchy, no overlay views, and availability only on devices that support video recording. It wins on effort, with zero UI code for trimming.

AVFoundation

AVFoundation is first-party, costs nothing and sits in the iOS SDK, with compositions, tracks and export sessions as building blocks. It wins on cost and dependency count. It has no editor UI and no face AR, beauty, background removal or automatic captions.

Banuba Video Editor SDK

A native iOS editor with its own UI, installed via CocoaPods or Swift Package Manager. The Video Editor SDK page lists transitions, an audio editor, text and GIFs, LUT color filters, templates, and Face AR with face filters and green screen background subtraction. Access starts with a 14-day trial token covering all features, then a license priced on monthly active users with no per-developer-seat fees and no public price list. Of the three licensed SDKs, it is the only one with a published size.

Two boundaries worth knowing before you add the pod. It does not cover browser editing, headless server rendering, or pro multi-track and HDR work. And it requires Xcode 26.0 or newer, which is the strictest toolchain requirement of the six routes and the one most likely to stop a prototype on day one, since it rules out build machines on an older macOS.

IMG.LY Video Editor SDK

Built on the CE.SDK engine, the IMG.LY video SDK runs on iOS, Android, web, React Native, Flutter, Electron, macOS and Mac Catalyst, plus a Node.js headless renderer. It handles MP4, WebM and MOV, and IMG.LY states GDPR compliance and SOC 2 Type II certification. Access is a custom quote metered by MAU, with each platform licensed separately and AI plugin usage billed by the model providers. It wins on platform reach and on trial length. Face AR and beauty are absent from its documented features, and it does not publish an SDK size.

Meishe StreamingSDK

Meishe pairs StreamingSDK with EffectSDK. It wins on editing depth: multi-track timelines, nestable sub-timelines, 4K editing, 8K image processing, HDR export with HLG or ST2084 curves, and 106- or 240-point face landmark models. Its access is the heaviest here: login-gated downloads, contact-sales pricing with no published figure, a per-app license bound to your bundle ID, a watermark until authorization, and 4K licensed separately. No SDK size is published.

Picsart Editor SDK

A web embed loaded by a CDN script tag, for desktop browsers only. Mobile browsers are not officially supported and WebView is explicitly unsupported, which rules out wrapping it in an iOS app. It also lacks real-time editing, allows one source video per project, and caps output at 1080p and 10 minutes. We did not evaluate its signup terms because it has no iOS path.

Step 3: How to trim and export a video with AVFoundation

For tier (a), this is the whole job. The function loads a clip, clamps the end time to the asset's duration, exports the range as MP4 at the highest-quality preset, and throws on each failure path.

Two export paths appear below, behind an availability check. The newer export(to:as:) is cleaner, and the completion-handler path is what runs on an iOS 15 deployment target. Confirm the exact availability badge on Apple's AVAssetExportSession reference against the SDK you build with, and delete the branch if your floor is above it.

import AVFoundation

enum TrimExportError: Error {
    case sessionUnavailable
    case mp4NotSupported
    case exportFailed
}

func trimAndExport(source: URL,
                   from startSeconds: Double,
                   to endSeconds: Double,
                   output: URL) async throws {

    let asset = AVURLAsset(url: source)
    let duration = try await asset.load(.duration)

    let start = CMTime(seconds: startSeconds, preferredTimescale: 600)
    let end = CMTimeMinimum(CMTime(seconds: endSeconds, preferredTimescale: 600), duration)

    guard let session = AVAssetExportSession(
        asset: asset,
        presetName: AVAssetExportPresetHighestQuality
    ) else {
        throw TrimExportError.sessionUnavailable
    }

    guard session.supportedFileTypes.contains(.mp4) else {
        throw TrimExportError.mp4NotSupported
    }

    session.timeRange = CMTimeRange(start: start, end: end)

    // Start from an empty destination path.
    try? FileManager.default.removeItem(at: output)

    if #available(iOS 18.0, *) {
        try await session.export(to: output, as: .mp4)
    } else {
        session.outputURL = output
        session.outputFileType = .mp4

        await withCheckedContinuation { continuation in
            session.exportAsynchronously {
                continuation.resume()
            }
        }

        switch session.status {
        case .completed:
            break
        case .cancelled:
            throw CancellationError()
        default:
            throw session.error ?? TrimExportError.exportFailed
        }
    }
}

// Caller
Task {
    do {
        try await trimAndExport(source: inputURL, from: 2, to: 12, output: outputURL)
        print("Export finished: \(outputURL.path)")
    } catch {
        print("Export failed: \(error.localizedDescription)")
    }
}

inputURL and outputURL are your own file URLs.

The export session comes back nil

The initializer is failable. Before blaming the file, call AVAssetExportSession.determineCompatibility(ofExportPreset:with:outputFileType:completionHandler:) with your asset and preset; Apple provides it for this check.

The export throws on the MP4 file type

Apple documents that the export throws when the file type is missing from supportedFileTypes. The guard in the snippet reports that case as its own error.

The export throws after the user leaves the screen

Apple's documentation says the export also ends on cancellation, and that cancelling the parent Task cancels it. If the task is tied to a view's lifetime, dismissing the view ends the export. The legacy branch surfaces the same case as a CancellationError.

Past this point, a timeline UI, filter previews and face effects during recording are yours to write.

Step 4: How to integrate a video editor SDK for iOS

Banuba: install, permissions, license check

The iOS requirements page sets the floor, and the integration guide walks through five tasks:

1. Add the pods with CocoaPods 1.12.1 or newer, or the packages with Swift Package Manager.
2. Add four usage strings to Info.plist: NSCameraUsageDescription, NSMicrophoneUsageDescription, NSPhotoLibraryUsageDescription and NSAppleMusicUsageDescription (media library).
3. Create a module class that builds a VideoEditorConfig.
4. Create BanubaVideoEditor with your license token.
5. Call getLicenseState and open the editor only when it reports a valid license.

Check the Xcode version on your build machines before step 1. The requirements page lists Xcode 26.0 or newer, and a CI image or a developer laptop on an older macOS will not get there with a pod install.

Banuba documents integration "in as little as 8 minutes"; that is our own claim, and the runnable ve-sdk-ios-integration-sample is how to test it on your machine. Teams using Claude Code, Codex or Qwen Code can install Banuba's agent skills and let the coding agent perform these steps.

BanubaVideoEditor returns nil

Per the docs, the initializer returns nil when the token is incorrect, for example empty or truncated. Check how the token reaches the binary first.

The editor opens to a "Video content unavailable" screen

The docs state this appears when the SDK starts with a revoked or expired license. The getLicenseState check in task 5 catches it before the user does.

IMG.LY: one pod, several licenses

On iOS, IMG.LY installs with pod 'IMGLYUI' via CocoaPods. The planning work is the license count, since iOS, Android, web and desktop are each licensed separately.

Meishe: license file before first frame

Meishe's iOS integration is written in Objective-C against NvsStreamingContext. Download requires a login, and output stays watermarked until the per-app license, bound to your bundle ID, is authorized. Media must also go via Meishe's transcoding service into its proprietary m3u8 format before it can sit on a track, so plan that step into your import flow.

Questions to ask about any client-side license token

The license token ships inside your app, so ask every vendor, including us:

How is the token scoped to the bundle ID, and what does the SDK do when the bundle ID differs?
What happens if someone lifts the token from the binary and ships it in another app?
How does revocation work, how fast does it reach installed apps, and what does the end user see?
Does license validation need a network call, and what does the SDK do offline?

Get the answers in writing.

Step 5: Measure before you commit

Three numbers settle most decisions, and each has to come from your own build.

Binary size delta

Archive the app with and without the SDK and compare. Banuba's requirements docs publish 14 MB for the core editor and 45 MB for the full bundle. IMG.LY and Meishe do not publish a size, so the archive diff is your only number for them.

Export wall-clock on your oldest device

Time one fixed clip in each route, the AVFoundation snippet included, on the slowest phone you support.

Trial window

Banuba gives 14 days with all features, IMG.LY 30 days with full access, and Meishe a trial authorization with watermarked output. Plan the test so it fits the shortest window you are using.

For more metrics, there is a list of seven numbers worth measuring inside your own app. If engineering time is the open question, run the build-versus-buy math next to these results.

How to choose between the routes

• If you are building a trim-and-share feature, use AVFoundation, or UIVideoEditorController if a portrait system view is acceptable, because both cost nothing and add nothing to your download.
• If you are building a creator or social app where face effects run while recording, use the Banuba Video Editor SDK, because the timeline UI and Face AR arrive in one dependency on iOS 15+; confirm your build machines can run Xcode 26 first.
• If your editor must also run on the web or render on a server, use IMG.LY, because one engine covers web, mobile and a Node.js renderer; budget for one license per platform.
• If you need multi-track timelines, 4K editing or HDR export, use Meishe, because its editing model goes deepest; start the license conversation early, since output stays watermarked until authorization.
• If the editor lives only in a desktop browser, Picsart's Editor SDK is the one that fits there; it is not an option for an iOS app.

Where each vendor ranks per criterion is covered in our iOS SDK comparison on the Banuba blog.

Stay on Apple's frameworks until effects or other platforms enter the plan

Tier (a) apps can ship on AVFoundation with the snippet above and no license. Once camera-time effects, a timeline UI, web reach or HDR depth appear on the roadmap, a licensed SDK is the shorter path, and the scenario list names which one. Size and export time measured in your own app confirm it within the trial window.

FAQ

What are the Banuba Video Editor SDK iOS requirements?

iOS 15.0 or newer, Swift 5.9 or newer and Xcode 26.0 or newer, installed through CocoaPods 1.12.1+ or Swift Package Manager. Banuba supports arm64 and arm64e, with limited x86-64 support. The Xcode floor is the one to check first, because it constrains your build machines rather than your users' phones.

Is there a free way to add video editing to an iOS app?

Yes. AVFoundation and UIVideoEditorController cost nothing. Among licensed options, Banuba offers a 14-day trial with all features, IMG.LY 30 days with full access, and Meishe a watermarked trial authorization.

Can the Banuba Video Editor SDK run in a browser or on a server?

No. Banuba covers native iOS and Android plus Flutter and React Native. For browser editing or headless rendering, IMG.LY's CE.SDK is the documented fit.

How is the Banuba Video Editor SDK priced compared with IMG.LY and Meishe?

Banuba prices on monthly active users with no per-developer-seat fees and no public price list. IMG.LY quotes per customer, metered by MAU, with each platform licensed separately. Meishe publishes no price and routes buyers to sales.