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. 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 is encrypted in transit (WebRTC, DTLS-SRTP) through Meeto's media servers in Europe and South-East Asia.

The upside is size and upkeep: no WebRTC framework in your binary, and calls improve when the hosted widget does. People in your app get the same lobby, video grid and chat as on the web and see the screens others share in the call. To simply join a meeting, they can also open the browser link or the Meeto app.

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. For join, leave or mute buttons, use MeetoWidgetView below, which takes commands, 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.

Production checklist and plan limits

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