Branch.io and Elido solve overlapping problems with non-overlapping architectures. Branch ships a mobile SDK that intercepts links inside your app, attributes the install, and routes the user to a destination. Elido handles deep linking entirely server-side — the redirect endpoint resolves the platform, returns the right Universal Link or App Link payload, and the OS does the rest. No SDK to integrate, no app update required for routing changes, no client-side state to debug.
This post compares the two on the dimensions that matter when you are evaluating: bundle size, attribution model, deferred deep linking, deep-link-on-open behaviour, custom-domain support, and the EU residency posture. The bitly alternatives cornerstone covers the broader competitive landscape; this is the Branch-specific comparison.
What Branch.io does#
Branch is a mobile measurement partner (MMP) with a deep-linking surface bolted on. The product was built around the install-attribution problem: a user clicks a link, installs your app, opens the app, and you need to know which campaign drove the install. Branch's SDK fingerprints the install, matches it against the click in their backend, and surfaces the attribution in a dashboard.
The deep-linking side rides along: a Branch link encodes a deep-link target plus an install-fallback URL. If the app is installed, Branch's SDK intercepts the link and routes inside the app. If the app is not installed, the link redirects to the App Store or Play Store; after install, the first app open triggers a deferred-deep-link callback that routes the user to the original target. That deferred path is the feature most teams pay Branch for.
The pricing surface is dense. Branch publishes plan tiers (Starter, Pro, Enterprise) but most of the relevant pricing is hidden behind a sales call, particularly for high-MAU apps or for the People-Based Attribution add-on. Public pricing pages list "Starter" at zero and "Pro" as "contact sales" (accessed 2026-05-22). For comparison shopping that absence is a real friction.
What Elido does#
Elido handles deep linking server-side. A short link points to a single resolver endpoint at the edge POP. When a request hits the endpoint, the resolver reads the User-Agent, looks at the link's deep-link configuration, and returns the appropriate response:
- iOS Safari with the app installed: a Universal Link payload pointing at the app's claimed domain. The OS opens the app directly.
- iOS Safari without the app installed: a redirect to the App Store with a smart App Banner.
- Android with the app installed: an App Link with the
intent://scheme as a fallback. - Android without the app installed: a redirect to Play Store with the package name attached.
- Desktop or non-app contexts: the canonical web destination.
The resolver runs in Go on fasthttp, hits the L1 LRU first, falls through to Redis at L2 if missed, and goes to origin only on a cold cache. The redirect p95 < 15ms post covers the full latency model. There is no SDK on the device. The OS-level handler does the routing; Elido provides the link metadata.
That architectural difference is the whole comparison. If you need the SDK-mediated install attribution that Branch offers (post-install deferred deep links, install-source fingerprinting, paid-channel attribution), Elido is not a drop-in replacement. If you only need deep links — the link-routing behaviour, the platform-aware fallback, the analytics — Elido is the smaller, faster, EU-resident option.
SDK weight comparison#
This is the line item where the architectural difference shows up in your app bundle.
| Surface | Branch SDK | Elido |
|---|---|---|
| iOS framework size (uncompressed) | ~3.5 MB | 0 KB |
| Android AAR (uncompressed) | ~2.8 MB | 0 KB |
| React Native bridge package | ~1.2 MB | 0 KB |
| Permissions requested (Android) | INTERNET, ACCESS_NETWORK_STATE, ad-id | none from Elido |
| App Tracking Transparency prompt (iOS) | required for IDFA | not applicable |
The Elido column is zero because nothing runs on the device for the redirect path itself. Universal Links and App Links are OS features; they do not require a third-party SDK. The link metadata (apple-app-site-association, assetlinks.json) is served from your domain; Elido helps you generate the files but does not embed code in your app.
For app teams running close to the 200 MB iOS App Store size limit or fighting bundle bloat on Android, removing the Branch SDK saves an objectively measurable chunk of binary size and one ATT prompt. For teams already at 50 MB total, the SDK weight is a rounding error.
The deep links without SDK post walks through what you actually need to ship on each platform when you go SDK-free.
Attribution model#
This is where Branch genuinely does something Elido does not.
Branch's install attribution model uses fingerprinting (IP + device characteristics) to match a pre-install click against a post-install device. The match is probabilistic but reliable enough for paid-acquisition attribution against Meta, TikTok, Google, and the major networks. Branch is also an SKAdNetwork (SKAN) measurement partner, which is the only deterministic post-IDFA attribution path on iOS.
Elido does not do SKAdNetwork. We attribute clicks server-side: every redirect is logged with its referrer, UTM parameters, and the destination it resolved to. We forward post-redirect events (purchases, sign-ups) to Meta CAPI, GA4, and TikTok Events API via the server-side conversion tracking pipeline. This works for the post-click attribution surface; it does not give you install-attribution against the iOS SKAN network or Android's Play Install Referrer.
For most B2B and prosumer apps, the post-click pipeline is what they actually need: a marketer needs to know that "the campaign drove the click, which drove the conversion". The install-attribution layer matters mainly for paid-mobile-acquisition at scale (gaming, ecommerce, social apps with seven-figure UA budgets). If you are buying paid installs, Branch is the right answer. If you are running owned channels (email, social organic, partnerships, content), Elido is the right answer.
Deferred deep linking#
Deferred deep linking — routing a user to a specific in-app destination after they install the app, where the install was triggered by clicking a link — is Branch's headline feature. The classic example: a user clicks a link to a specific product, installs the app, and lands on that product's page rather than the app's home screen.
Elido supports deferred deep linking through a different mechanism. The short link encodes the in-app destination as a query parameter on the App Store fallback URL. After install, the app's first launch reads https://apps.apple.com/...?referrer=elido_link_id=abc123 (or the Play Install Referrer equivalent on Android), calls the Elido API to resolve the original link, and routes the user.
This requires one API call from the app on first launch — no SDK, just a network request and a router. The pattern is documented in the deep links without SDK post and the /docs/guides/deep-links operational walkthrough. Match rate is high (>95% in our testing) because the install referrer flows through the platform-provided channel.
The downside: it requires app-side integration. You add an HTTP client and a router in your launch path. With Branch's SDK, the deferred routing is automatic; with Elido, the app has to opt in. That is the work you save in SDK bytes and ATT prompts.
Custom domain support#
Branch supports custom domains on the Pro plan and above (pricing on request). The setup requires a CNAME at your DNS provider pointing at Branch's edge, plus Branch-side verification.
Elido supports custom domains on all paid tiers. The TLS certificate issues via Caddy's on-demand TLS within 60 seconds of CNAME propagation. The custom domains for short links walkthrough covers the DNS flow. There is no separate domain-verification step; the certificate issuance is the verification.
For the deep-link case, custom domains matter because Universal Links and App Links require the link domain to match the apple-app-site-association file's webcredentials and applinks services. The assetlinks.json on Android works the same way. Both files have to be served from the custom domain over HTTPS with a valid certificate.
Elido auto-generates and serves both files when you configure deep links for a domain. The configuration lives at /settings/apps in the dashboard; the /features/deep-links page covers the product surface, and the /docs/guides/deep-links guide covers the operational details.
EU residency#
Branch is a US company. The Branch backend runs on AWS in the US; the data plane is not EU-resident. For a US-based app team this is fine; for an EU-resident app or any team that needs GDPR-compliant data residency, it is a procurement blocker.
Elido is EU-first. The data plane runs on Hetzner Frankfurt and OVH Strasbourg, with Postgres source-of-truth in EU regions and ClickHouse click analytics replicated to the EU. The GDPR for URL shorteners cornerstone covers the data-residency posture in detail; the EU data residency for marketing post covers the procurement-side answer.
For teams where the DPO has to sign off on every vendor's data-flow diagram, this is often the single most important differentiator. Schrems II and tracking pixels covers the legal context for why a US-resident attribution vendor is harder to defend than an EU-resident one.
When Branch is the right answer#
To be clear about where Branch wins:
- You are buying paid mobile installs at scale. SKAdNetwork integration is table stakes for paid-UA on iOS post-IDFA. Branch is an MMP; Elido is not.
- You need attribution against the major ad networks out of the box. Branch has direct integrations with Meta, TikTok, Google Ads, Apple Search Ads, and dozens of smaller networks. Elido forwards conversions but does not act as an MMP.
- You want a single vendor for both install attribution and post-install events. Branch unifies the two; Elido is a deep-link plus post-click attribution layer that pairs with an MMP if needed.
If any of those are dealbreakers, stop reading and pick Branch. The other 80% of the deep-linking use cases — content sharing, email campaigns, partner integrations, in-app referrals, owned-channel routing — Elido handles with less weight.
When Elido is the right answer#
The clearer wins for Elido:
- You ship a B2B or prosumer app. The marketers' workflows are post-click, not install-attribution. Email, partner links, content marketing, referral programs.
- You care about app bundle size or ATT prompt count. Removing the Branch SDK saves about 3.5 MB on iOS and one ATT prompt.
- You need EU data residency. US-resident attribution data is a Schrems II problem; EU-resident is not.
- You want one tool for short links and deep links. Branch handles deep links; Bitly or Rebrandly handle short links. With Elido, the same link record handles both — the same UTM templates, the same analytics, the same campaigns.
- You prefer no SDK on the device. Faster ship, no breakage when iOS or Android changes their privacy posture, one fewer thing to debug.
Side-by-side feature matrix#
| Capability | Branch.io | Elido |
|---|---|---|
| Mobile SDK required | yes (iOS + Android + RN) | no |
| App bundle impact | ~3-5 MB | 0 |
| Universal Links / App Links | yes | yes |
| Deferred deep linking | SDK-mediated | install-referrer + API call |
| Install attribution | yes (fingerprint + SKAN) | no |
| Post-click attribution | yes | yes |
| Meta CAPI / GA4 server-side forwarding | yes | yes |
| Custom domain | Pro+ | all paid tiers |
| EU data residency | no | yes |
| Per-link UTM templates | yes | yes |
| Webhook events | yes | yes (details) |
| Public pricing | partial | full |
| ATT prompt required (iOS) | yes (for IDFA) | no |
| Open API + SDKs | yes (REST) | yes (5 langs) |
Procurement answer#
For the procurement team running a vendor comparison: Branch is the leader in mobile install attribution and the right pick if SKAdNetwork integration is in your top three requirements. Elido is the right pick if deep linking, post-click attribution, EU residency, and zero SDK weight rank higher than paid-UA attribution.
For most B2B and prosumer apps, the comparison resolves to Elido. The Branch SDK is overhead you pay for a feature you do not use. The free URL shorteners ranked post covers the broader cost comparison; /pricing has Elido's full plan matrix.
If you are currently on Branch and considering a switch, the migrate-from-bitly playbook covers the general migration mechanics — export your link records, map the destinations, redirect the old domain or re-issue the links on yours. The Branch-specific export is a CSV of link configurations from the Branch dashboard; the rest is the same flow.
External references#
- Apple's Universal Links documentation — what the
apple-app-site-associationfile does. - Google's App Links verification — the
assetlinks.jsonmechanism. - Apple's App Tracking Transparency framework — what the IDFA prompt actually requires.
Related reading#
- Bitly alternatives — the actual feature gap — the comparisons cornerstone.
- Deep links for mobile apps without an SDK — the full server-side deep-link walkthrough.
- Smart links explained — the platform-aware routing system Elido uses.
- GDPR for URL shorteners — the EU residency cornerstone.
- Custom domains for short links — the DNS + TLS walkthrough.
- Product surfaces:
/features/deep-links,/features/smart-links,/solutions/developers. - Operational guides:
/docs/guides/deep-links,/docs/guides/smart-links.