iOS SDK

The Uplink iOS SDK embeds a worker inside your iOS app, making the device controllable from server-side code written with the JavaScript SDK. Use it when you want Uplink automation to run inside your own branded app.

Key concepts:

Device: A physical iOS device running your app
Worker: A worker created by the Uplink SDK inside your app (one app can create multiple workers)
Session: An authenticated connection that pairs your worker with a JavaScript SDK client

Requirements

iOS 15.0 or later
Xcode 26.1 or later

Installation

The iOS SDK is distributed via Swift Package Manager.

Add the package

In Xcode, go to File → Add Package Dependencies… and enter:

https://github.com/uplink-code/uplink-ios-public

Select a framework variant

Choose either the static Uplink library product or the Uplink-Dynamic library product and add it to your app target. Link only one variant.

Import the module

import Uplink

If you manage dependencies with a Package.swift file:

dependencies: [
    .package(url: "https://github.com/uplink-code/uplink-ios-public", from: "1.0.0")
],
targets: [
    .target(
        name: "YourApp",
        dependencies: [
            .product(name: "Uplink", package: "uplink-ios-public")
        ]
    )
]

Uplink is static by default. If your app requires dynamic linking, depend on .product(name: "Uplink-Dynamic", package: "uplink-ios-public") instead. Do not link both variants.

Quick example

import UIKit
import Uplink

@MainActor
func startUplink(in viewController: UIViewController, session sessionUrl: String) async throws {
    let worker = await Worker(controller: viewController)

    try await worker.connect(session: sessionUrl)

    Task {
        // accept() blocks until the worker finishes.
        await worker.accept()
    }
}

Initialization

Create a Worker with the UIViewController that will present the browser, usually the view controller currently on screen. Retain each active worker for as long as its connection is active.

let worker = await Worker(controller: viewController)

`Worker(controller:)`

Creates a new Worker associated with a UIViewController. The SDK uses that controller to host its WKWebView.

Worker(controller: UIViewController) async

Parameters:

controller: The UIViewController that will host the SDK’s web view

Returns: A new Worker ready to connect to a session

let worker = await Worker(controller: self)

Keep a strong reference to the Worker for as long as the connection is active. If the worker is deallocated, the session will close.

Obtaining a session

Your backend creates a session using the JavaScript SDK’s uplink.session() and delivers the resulting session URL to the app. How you deliver it — a backend API response, a universal link, a QR code — is up to you.

let sessionUrl: String = // from your backend, deep link, or QR code

See Sessions for how sessions are created on the server side.

Connecting and accepting

`worker.connect(session:)`

Connects the worker to an Uplink session.

func connect(session: String) async throws

Parameters:

session: The session URL provided by your backend

try await worker.connect(session: sessionUrl)

`worker.accept()`

Begins accepting commands from the JavaScript SDK client. accept() suspends until the worker closes, so call it from a Task to avoid blocking the rest of your app.

func accept() async

Task {
    await worker.accept()
}

`worker.watch(_:)`

Registers a callback for worker events. Callbacks are not delivered on the MainActor. If a callback updates UIKit or other main-actor-isolated state, explicitly hop to the main actor.

await worker.watch { [weak self] event in
    switch event {
    case WorkerEvent.terminated:
        Task { @MainActor in
            // Update UI.
        }
    // Optionally handle other Page or Worker events.
    default:
        break
    }
}

Cleanup

`worker.close()`

Closes the worker and releases its resources.

func close() async

await worker.close()

Closing a worker ends its session. Any browsers the JavaScript SDK has launched on the worker will be terminated.

Complete example

A minimal UIViewController that starts an Uplink worker when it appears: For a complete working app, see the Connect example.

import UIKit
import Uplink

final class UplinkViewController: UIViewController {
    private var worker: Worker?

    func start(sessionUrl: String) {
        Task {
            let worker = await Worker(controller: self)
            self.worker = worker

            do {
                try await worker.connect(session: sessionUrl)
                await worker.accept()
            } catch {
                print("Uplink worker ended: \(error)")
            }
        }
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)

        Task { [worker] in
            await worker?.close()
        }
    }
}

Android SDK

Integrate Uplink into your Android app

JavaScript SDK

Control your worker from server-side code

Sessions

How sessions are created and secured

Core concepts

Architecture overview

JavaScript SDK

Native SDK

Page API

AI Automation

Requirements

Installation

Quick example

Initialization

`Worker(controller:)`

Obtaining a session

Connecting and accepting

`worker.connect(session:)`

`worker.accept()`

`worker.watch(_:)`

Cleanup

`worker.close()`

Complete example

Android SDK

JavaScript SDK

Sessions

Core concepts

​Requirements

​Installation

​Quick example

​Initialization

​Worker(controller:)

​Obtaining a session

​Connecting and accepting

​worker.connect(session:)

​worker.accept()

​worker.watch(_:)

​Cleanup

​worker.close()

​Complete example

​Related

Android SDK

JavaScript SDK

Sessions

Core concepts

Requirements

Installation

Quick example

Initialization

`Worker(controller:)`

Obtaining a session

Connecting and accepting

`worker.connect(session:)`

`worker.accept()`

`worker.watch(_:)`

Cleanup

`worker.close()`

Complete example

Related