The SDK

One line of code. Two plist values. That’s the install.

PharenSDK is Swift, distributed with Swift Package Manager, Foundation only — zero third-party dependencies. No config code, no secrets to guard: it configures itself from your Info.plist, and the ingest key is public by design, like a crash-reporter DSN.

The fast path

Your release pipeline, in one call.

Registering releases, uploading dSYMs, and minting install links doesn’t need a setup project. Pick whichever matches how you ship:

Already on fastlane

$ fastlane add_plugin pharen

rubyFastfile

lane :beta do
  build_app(scheme: "MyApp")
  pharen_release   # release · dSYMs · build · OTA link
end

With no arguments, pharen_release finds the IPA and dSYMs in the lane context, reads version, build, and bundle id from the IPA’s own Info.plist, and prints the OTA install link. The plugin is MIT-licensed, on RubyGems.

No fastlane? One command sets up the repo

$ pharen init ios --org your-org --app your-app-id
→ wrote .pharen.yml · release/release-lane.sh

$ PHAREN_AUTH_TOKEN=… bash release/release-lane.sh
→ archive · upload-build · upload-symbols
itms-services://…/manifest.plist

init is purely local — no network, no prompts. It writes your committed config and the canonical release lane; every release after that is the one lane command.

Both paths run on the pharen CLI, which we provide with your credentials at onboarding — there’s no public download yet. And either way, the SDK still goes into your app the same three-step way below; that part is already the short version.

By hand

The SDK itself: three steps, about five minutes.

No wizard needed — this is the whole thing, and it’s the same whichever release path you chose.

1 / 3

Add the package

In Xcode, File → Add Package Dependencies…, or add it to your Package.swift. Pin a SemVer major range.

swiftPackage.swift

dependencies: [
    .package(
        url: "https://github.com/pharen-ai/sdk-ios.git",
        from: "0.1.0")
]

2 / 3

Set two Info.plist values

Your ingest key, and the consent purposes you grant at launch. The key ships in your binary and carries no read access — the server derives your tenant, app, and environment from it. Commit it.

No key, no consent — nothing is sent. A missing or placeholder key leaves the SDK completely off: the intended way to disable Pharen in local builds.

xmlInfo.plist

<key>PharenIngestKey</key>
<string>YOUR-INGEST-KEY</string>

<key>PharenConsentGranted</key>
<array>
    <string>telemetry</string>
</array>

3 / 3

Start Pharen

One line, as early as possible in your app’s lifecycle. It installs the crash handlers, starts a session, and begins delivering events in batches, off the main thread. Unconfigured, it returns nil and installs nothing.

swiftMyApp.swift

import PharenSDK
import SwiftUI

@main
struct MyApp: App {
    init() {
        Pharen.start()   // reads both values from Info.plist
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

After start()

The surface you’ll actually touch.

Crash capture and sessions run without another line. The rest is small enough to read in a minute.

Pharen.shared?.track(_:properties:)

A named event with optional properties. Behavioral-class — needs behavioral consent.

Pharen.shared?.screen(_:)

A screen view. Same consent class, same envelope, same timeline.

Pharen.shared?.identify(_:traits:)

Connect activity to a known user. Traits route to the restricted attribute store — never onto the event stream, never into logs.

Pharen.shared?.crashes.recordError(…)

Handled errors with stack, severity, and breadcrumbs. Telemetry-class, durable queue.

Pharen.shared?.consent.grant(_:) / revoke(_:)

Runtime consent — for example, after your banner returns. Takes effect immediately.

Pharen.shared?.deepLinks.onLink / handle(_:)

Universal-link routing through one hook. Routing fires regardless of consent; the open event carries the route path only — never the query string.

Pharen.shared?.deepLinks.createLink(…)

Campaign-tagged short links on pharen.link, in the same event timeline as everything else.

Pharen.crashTest()

A deliberate crash, shipped in the SDK, for verifying your pipeline in a Debug build.

Full documentationQuickstart to first crash report: about five minutes.

Licensing, plainly: SPM installs the SDK as source, so you can read every line that ships in your binary. It’s source-available under the Pharen license — auditable, not open source. The integration glue (the fastlane plugin, the release-lane template) is MIT.