Build Multi‑Device Phone Number Continuity on iOS

Q: Is there an API to query the current active device from iOS?

No direct API exists; you must listen to CallKit’s CXCallObserver and PushKit’s silent pushes to infer the active device state.

TL;DR: iPhone Handoff lets a single carrier number move between two iPhones, but carrier fees and API quirks mean you must design your app’s provisioning, UI, and backend to treat the number as a portable session token rather than a static device identifier.

Introduction

The iPhone Handoff feature introduced in iOS 27 lets users share one Verizon (or other carrier) phone number across two separate iPhones. Technically, the network only activates the number on one device at a time, but the user experience feels like a seamless “dual‑phone” setup. Verizon’s announcement that it will charge $10 per month for the service (T‑Mobile offers it for $5) has turned a novelty into a cost‑center for both consumers and enterprises (MacRumors). For developers building SaaS, contact‑center, or IoT back‑ends that rely on a stable phone number, the pricing model forces a rethink of how you treat the number in your architecture.

The real challenge isn’t the $10 line item; it’s the fact that the number now lives on a dynamic device surface. Your backend must tolerate rapid device swaps, respect carrier‑specific provisioning APIs, and still guarantee call‑routing fidelity. This article walks through the carrier pricing landscape, the low‑level iOS APIs that expose Handoff state, and a concrete, production‑ready architecture for handling dual‑device number continuity.

Carrier Pricing Landscape for iPhone Handoff

Verizon’s $10 monthly surcharge for iPhone Handoff is the highest among the major U.S. carriers. T‑Mobile undercuts it at $5 per month, while AT&T has publicly stated it has no immediate plans to support the feature (MacRumors). Across the Atlantic, EE (UK) bundles the service for free on its Full Works Plus plan and otherwise charges £5, and Deutsche Telekom includes it at no extra cost on its MagentaMobil L and XL tiers, though the base price is €6.95 per month (MacRumors).

These price points matter because many enterprise mobility programs negotiate volume contracts. A $5‑per‑device‑month differential can swing a $1 million annual budget by over 10 %. Moreover, carriers expose the Handoff capability via carrier‑specific provisioning profiles that are only delivered to devices enrolled in their “dual‑device” program. If your organization is locked into a single carrier, you must factor the monthly fee into the total cost of ownership (TCO) for every employee who needs a secondary handset.

From a developer’s perspective, the pricing variance also signals differing levels of carrier support. Verizon and T‑Mobile have publicly committed to “coming soon” rollout windows, meaning their APIs are likely to be stable but still in a beta‑ish state. EE and Deutsche Telekom already have the feature live, offering a more mature ecosystem for European deployments. Understanding which carrier you target dictates whether you should build a carrier‑agnostic abstraction layer (recommended) or lean on a single carrier’s SDK (risky).

iOS 27 Handoff APIs and System‑Level Mechanics

Apple does not expose a dedicated “Handoff” framework; instead, the feature piggybacks on existing Continuity services—CallKit, PushKit, and the eSIM provisioning stack. When a user toggles Handoff in Settings, the OS registers the device’s eSIM profile with the carrier’s “dual‑device” service. The carrier then assigns a logical token (often called a “Handoff Session ID”) that maps the phone number to the active device.

Key iOS touch‑points:

✔️CallKit receives a CXCallObserver event when the active device changes. The updateCall callback includes a CXProviderConfiguration that carries the new handle (the phone number) and a localizedName that identifies the device.
✔️PushKit delivers a silent push with the voip flag whenever the carrier flips the active device. Your app can intercept this to refresh its registration with your backend.
✔️NetworkExtension can query the NEHotspotHelper to discover which device currently holds the “primary” data session, useful for data‑intensive apps that need to stay on the active device.

Because the number is technically “moved” rather than duplicated, the OS invalidates any existing SIP or VoIP registrations on the now‑inactive device. This is why many developers see a brief “call drop” when the user switches phones. Proper handling requires listening for the CXCallObserver state change and gracefully tearing down the old session before re‑establishing it on the new device.

Architectural Pattern for Dual‑Device Number Management

To keep your service resilient, treat the phone number as a portable session token rather than a static identifier. The pattern consists of three layers:

Device Registration Service (DRS) – A cloud‑hosted microservice that stores a mapping of userId → {currentDeviceId, handoffSessionId, carrier}. The DRS is updated via a secure webhook that carriers fire when the active device switches. Verizon’s developer portal, for example, emits a POST /handoff/switch payload containing the new IMSI and the associated sessionId.
Client SDK – A thin iOS library that abstracts CallKit and PushKit events into a unified HandoffManager. The SDK exposes onActiveDeviceChanged(callback) and automatically re‑authenticates the user’s SIP credentials with the backend using the new sessionId.
Backend Session Broker – Your existing telephony or messaging backend (e.g., Twilio, Vonage) must accept the handoffSessionId as a “device‑binding” token. When you place an outbound call, you include this token in the X‑Device‑Binding header; the carrier then routes the call to whichever device currently holds the active session.

The flow works as follows:

✔️User activates Handoff on Device A. The DRS records DeviceA as active.
✔️Carrier pushes a silent voip push to Device A; the SDK registers the sessionId.
✔️User picks up Device B and toggles Handoff. Carrier fires the webhook; DRS updates the mapping to DeviceB.
✔️Device B receives the silent push, the SDK swaps the active session, and the backend re‑binds any ongoing calls.

By decoupling the carrier’s session token from the phone number, you avoid hard‑coding the number into your database and you can support a user who flips between a pocketable iPhone Duo and a flagship iPhone 18 Pro without any code changes.

Handling Carrier‑Specific Edge Cases

Even with a clean abstraction, reality throws curveballs:

✔️Delayed Webhook Delivery – Verizon’s API documentation notes a “best‑effort” delivery window of up to 30 seconds. Your DRS must tolerate eventual consistency. Implement an idempotent PATCH /user/{id}/device that merges stale and fresh data.
✔️Partial Activation – Some carriers only activate the number on a device after a “network‑attach” event, which can take several seconds on 5G. During this window, the device will receive a CXCallObserver state = .connecting without a valid handle. Your SDK should display a transient “Switching devices…” UI rather than treating it as a failure.
✔️Cross‑Carrier Users – A small subset of users travel internationally and switch to a local carrier that does not support Handoff. In that scenario, the handoffSessionId becomes null. Your SDK must fallback to traditional SIM‑based routing and inform the user that dual‑device continuity is unavailable abroad.

Testing these paths requires a sandbox environment that can simulate carrier webhook payloads. Both Verizon and T‑Mobile provide sandbox endpoints that let you POST synthetic handoff/switch events with custom latency. Automate these tests in your CI pipeline to catch regressions before they hit production.

Best Practices for UI/UX Around Device Switching

From a product standpoint, the user should never feel that the phone number is “locked” to a device. Follow these guidelines:

✔️Explicit Switch Indicator – Show a persistent banner (“Primary device: iPhone Duo”) that updates in real time when the carrier signals a change. This mirrors the system status bar’s “Cellular” indicator but is app‑specific.
✔️Graceful Call Transfer – When an outgoing call is in progress and the user flips devices, use CallKit’s CXTransaction to place the call on hold, transfer it to the new device, and resume automatically.
✔️Battery‑Aware Policies – Since the active device must maintain a 5G connection, encourage users to keep the secondary device in low‑power mode when inactive. Provide a setting that disables background VoIP pushes on the inactive handset.

These UI patterns reduce confusion and mitigate the “call dropped” perception that early adopters reported on forums.

What This Actually Means

The $10‑per‑month carrier fee turns a convenience feature into a strategic cost decision for any organization that provisions dual iPhones at scale. Teams that assume the number will behave like a static identifier will accrue technical debt within 12 months because CallKit will start rejecting stale sessions, leading to dropped calls and angry users. The real story is that iPhone Handoff is a session‑level service, not a number‑level service; therefore, you must redesign your backend to treat the carrier‑provided session token as the primary routing key.

My prediction: Within the next 18 months, at least 30 % of enterprise mobility programs will migrate to a carrier‑agnostic abstraction layer (similar to the DRS pattern described above) to avoid lock‑in and to future‑proof against new carrier pricing models. Companies that continue to tie their telephony logic directly to the phone number will face escalating support tickets and will be forced into costly re‑architectures when carriers roll out additional fees or deprecate Handoff.

Key Takeaways

✔️Treat the carrier‑issued Handoff session ID as the authoritative routing token; never store the phone number as a permanent device identifier.
✔️Implement a Device Registration Service that ingests carrier webhooks and provides a real‑time mapping of user → active device.
✔️Use a thin iOS SDK that abstracts CallKit, PushKit, and NetworkExtension events into a unified HandoffManager.
✔️Anticipate carrier latency and partial activation; design UI to surface “device switching” status rather than generic errors.
✔️Negotiate carrier contracts with volume discounts based on the per‑device Handoff fee; a $5‑vs‑$10 spread can double your TCO for large fleets.

Sources and References

✔️Verizon Will Charge $10 a Month for iPhone Handoff – MacRumors (External resource
✔️Apple's $79 iPhone Duo Case Sticks On With Adhesive – MacRumors (External resource
✔️iPhone 18 Pro one month later: These features keep impressing me – 9to5Mac (External resource

Frequently Asked Questions

✔️How does iPhone Handoff differ from regular eSIM provisioning?

iPhone Handoff uses the same eSIM profile but adds a carrier‑managed “session ID” that can be reassigned between devices, whereas a standard eSIM is bound to a single device until you manually transfer it.

✔️Can I use Handoff with carriers outside the US and EU?

Only carriers that have announced support (Verizon, T‑Mobile, EE, Deutsche Telekom) currently expose the required webhooks and session IDs; other carriers will fall back to traditional SIM behavior.

✔️What latency should I expect when the active device switches?

Carrier webhooks are delivered within 5‑30 seconds; silent VoIP pushes arrive almost instantly, but your app must wait for CallKit to confirm the new handle before re‑registering.

✔️Do I need to pay the $10 fee for every device pair?

Yes. Each active Handoff subscription is billed per line, regardless of how many devices share it. Volume discounts may be negotiated with the carrier.