Add a video call to an iOS app.

How does the iOS SDK work?

The SDK wraps the hosted Meeto widget in a web view; it is not a native video engine. MeetoWidgetView loads https://meeto.me/embed with your key in a WKWebView, sends commands into the page and turns the page's messages into Swift events. Every call runs through Meeto's media servers and is encrypted in transit, not end to end.

The upside is size and upkeep: no WebRTC framework in your binary, and calls improve when the hosted widget does. The trade-off is that the call behaves like Meeto in a mobile browser. The screen-share button appears only where the web view offers screen capture to pages, which iPhone web views do not, so people in your app see screens others share rather than share their own. If your users only need to join meetings, the browser link or the Meeto app may be enough.

Install the Swift Package

Add the package by its repository URL in Xcode, or declare it in Package.swift. The current tag is 0.1.2, and the library product is MeetoWidget.

// Xcode → File → Add Package Dependencies…
// https://github.com/meeto-app/meeto-widget-ios.git

// or in Package.swift:
dependencies: [
    .package(url: "https://github.com/meeto-app/meeto-widget-ios.git", from: "0.1.2")
]

Set up the key and permissions

A native app has no web origin, so the SDK presents itself as app:// plus your bundle identifier. In Settings → Website widget, create a key and add that origin, for example app://com.example.myapp. Without it the widget reports an error instead of loading the call.

Add both usage descriptions to Info.plist. iOS terminates an app that touches the camera or microphone without them.

<key>NSCameraUsageDescription</key>
<string>The camera is used for video calls.</string>
<key>NSMicrophoneUsageDescription</key>
<string>The microphone is used for video calls.</string>

An app origin is declared by the SDK rather than checked by a browser, so treat the mk_live_… key as public, as it is on the web. The server key mk_secret_… never belongs in an app.

Show a call in SwiftUI

MeetoWidget is a SwiftUI view that takes a configuration and an event closure. Give it a frame; the call fills it.

import SwiftUI
import MeetoWidget

struct SupportCallView: View {
    @Binding var isPresented: Bool

    var body: some View {
        MeetoWidget(config: .init(key: "mk_live_…", roomName: "support", userName: "Anna")) { event in
            switch event.type {
            case "joined":
                print("joined room", event.payload["room"] as? String ?? "")
            case "left":
                isPresented = false
            case "error":
                print("Meeto error", event.payload["code"] as? String ?? "")
            default:
                break
            }
        }
        .frame(maxWidth: .infinity, minHeight: 520)
    }
}

The configuration is fixed when the view is created. To switch rooms or keys, give the view a new identity with .id(roomCode) so SwiftUI builds a fresh one. The SwiftUI view does not expose commands; for join, leave or mute buttons, use MeetoWidgetView below or wrap it in your own UIViewRepresentable.

Use UIKit and send commands

MeetoWidgetView is a UIView that starts loading as soon as you create it. Pin it with constraints and keep a reference for commands.

import UIKit
import MeetoWidget

final class CallViewController: UIViewController {
    private var widget: MeetoWidgetView!

    override func viewDidLoad() {
        super.viewDidLoad()
        // An open room your server created with POST /api/embed/rooms
        widget = MeetoWidgetView(config: .init(key: "mk_live_…", room: "misty-fox-a18f493cb027fe823cb6", userName: "Anna"))
        widget.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(widget)
        NSLayoutConstraint.activate([
            widget.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            widget.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            widget.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            widget.trailingAnchor.constraint(equalTo: view.trailingAnchor),
        ])
        widget.onEvent = { [weak self] event in
            if event.type == "left" { self?.dismiss(animated: true) }
        }
    }

    func muteMe() { widget.setMicrophone(false) }
    func leaveCall() { widget.leave() }
}

Events arrive on the main thread as MeetoEvent values: a type string and the full payload dictionary of the widget protocol, the same events the JavaScript SDK emits. Commands can be called from any thread.

Limits and production checklist

Limits follow the plan of the account that owns the key. Recording and AI summaries are started by a Pro or Team host; see pricing.

Frequently asked questions

Explore more with Meeto