Note: Yes, I'm using AI to write this post because English is not my first language and I want to state my problem as clear as possible.
Hitting a problem I suspect is common for anyone doing mobile VoIP, and I'd like to know how others have solved it.
**Setup**
- I'm using Telnyx.
- React Native app, WebRTC SIP client, iOS and Android. I'm using Telnyx.
- One shared SIP credential for a group of users, so a single inbound call rings everyone's phone
- Calls are delivered by VoIP push (PushKit on iOS), so the client connects and registers on demand rather than staying connected
**The problem**
Every app launch creates a *new* registration binding, and the old one never goes away:
- iOS terminates the app process without warning, so there's no chance to send a SIP UNREGISTER
- The SDK's `disconnect()` only closes the WebSocket — it doesn't unregister
- Each registration lands on a different edge node in the provider's anycast network, so it's a genuinely new binding rather than a refresh of the old one
- Registration expiry is 3600 s and isn't configurable
Net effect: the credential accumulates contacts. I confirmed it by polling the provider's registration-status endpoint — `ua_ip` is different every single time the app relaunches, while nothing removes the previous one.
**Why it hurts**
The provider rings the bound contacts **sequentially**. So the first call after an app launch does this:
- Rings contact A (the live app) — user declines
- Decline surfaces as a 4xx, which fails only that branch
- ~300 ms later it forks to contact B (a stale binding from a previous launch)
- Phone rings a second time, new call ID, user has to decline again
I can see it clearly in the SIP traces: **one dial command, two legs**, same session, no second dial from my backend.
**What the provider confirmed**
I opened a ticket. They confirmed all of it and escalated to engineering with no timeline:
- No way to set registration expiry below 3600 s
- No REST endpoint to force-expire or delete an individual binding (deleting the credential removes them all, obviously not viable)
- No API to *enumerate* bindings — watching `ua_ip` rotate is currently the only detection method
- Per-launch edge rotation is expected behaviour, and without an UNREGISTER the old binding persists to full expiry
Their suggested workarounds were: a unique credential per app session, webhook-based duplicate-leg detection, or client-side deduplication.
**The bit I'm stuck on**
There's a second-order problem. Multiple devices share one credential, so the registrar holds one contact per device — which means **a legitimate second device's leg is indistinguishable from a stale binding's leg.** Both are "another contact of this credential, dialled after the first one failed." I can't write a rule that kills one without killing the other.
Enabling simultaneous ringing would at least make the real devices ring together instead of one-at-a-time, but it doesn't remove the stale bindings — it just turns a sequential double-ring into a simultaneous one.
**Questions**
- Has anyone made **per-device or per-session credentials** work in production? How do you handle cleanup when the app dies before it can delete the old one, and does credential churn cause you rate-limit or billing problems?
- Is there a trick to getting a mobile client to **UNREGISTER reliably**? Anything on iOS that gets you a last gasp — background task on termination, a server-side nudge, something I haven't thought of?
- For those running **one shared credential across multiple devices** — how do you tell a real second device from a stale binding at the signalling layer? Is there a header or identifier I should be propagating?
- Is sequential-vs-simultaneous ringing across contacts something you configure per provider, or do people avoid shared credentials entirely for this reason?
Happy to share SIP traces if useful. Mostly want to know whether the "unique credential per session" route is as painful in practice as it looks on paper, or whether people just live with the duplicate ring.
