The ecommerce funnel has more touchpoints than any other vertical I work with. A customer sees a Meta ad, clicks through to a product page, abandons the cart, gets a recovery email three hours later, scans a QR code on the package after delivery, and rebuys via the post-purchase WhatsApp flow nine days later. Every one of those touches goes through a URL - and every URL needs to be attributable, redirectable, and durable enough to survive the next ad-platform privacy update.
This is the cornerstone post for the ecommerce cluster. It covers the integration shape that holds the funnel together: where the short link sits in each stage, what attribution data it carries, how server-side conversion forwarding closes the loop with the ad platforms, and what the operational tooling looks like when you're running a reasonable Shopify shop with two paid channels and a lifecycle programme.
I'll be specific about Shopify because it's the platform I see most often, but the patterns generalise. WooCommerce, BigCommerce, Centra, Commercetools - the integration points are the same; only the webhook payload shape differs.
The five stages of the ecommerce funnel#
Every funnel I audit has the same shape. The implementation differs in detail, the stages don't.
Paid acquisition. Meta, Google Ads, TikTok, Pinterest. The ad surface holds the creative; the destination is a short link that captures the click and forwards to the landing page or product detail page (PDP) with attribution parameters preserved.
Owned channel acquisition. Email, SMS, push, in-app messaging, WhatsApp. The shortener mints links per send (transactional templating against a campaign) so analytics roll up by send rather than by URL.
On-site conversion. The PDP, the cart, the checkout. The shortener is not on the request path here - the click already landed - but the click_id from the redirect needs to make it onto the order record so the conversion can be tied back later.
Post-purchase. Order confirmation page, order confirmation email, packaging insert, the QR code on the box. Short links carry the customer through the post-purchase experience and deliver the data signal back into the marketing data plane.
Retention and reactivation. Lifecycle email, abandoned-cart recovery, product-back-in-stock alerts, win-back campaigns. The shortener sees these as a long tail of programmatic mints, often via an integration with the ESP or marketing automation platform.
Each stage has a slightly different attribution requirement. The integration shape that handles all five is what this post is about.
Stage 1: paid acquisition#
The job at this stage is twofold. The short link has to land the user on the right destination, and it has to capture enough attribution context that the order - placed three hours later via a different device after a refresh and a discount-code dance - can be tied back to the ad.
The shape that works: the ad's destination URL is a short link (elido.me/spring-jeans-de or whatever the slug convention is), the short link redirects to the PDP with the UTM and click_id parameters appended, and the redirect response sets a first-party identifier that survives the navigation.
In Elido's case, the redirect appends ?elido_click=<click_id> (configurable per workspace), and the PDP either reads it from the query string and writes it to a first-party cookie, or - better - the shop platform's tag manager picks it up via the dataLayer event and persists it in the order's custom attributes when the cart is finalised.
The benefit of this shape is that the click_id is the durable identifier across the rest of the funnel. The browser cookie can be lost to ITP. The session can expire. The user can switch device. As long as the click_id is on the order record, you can run a server-side conversion forward at order-paid time and get attribution credit even when the original browser session is dead.
For the operational mechanics - UTM template at the workspace level, campaign-level overrides, bulk import from Sheets, conversion forward verification - the end-to-end UTM tracking guide is the cornerstone reference.
Stage 2: owned channel acquisition#
Owned channels are higher-volume, lower-cost, and harder to measure than paid. Every email send to a 100K-subscriber list mints 100K short links if the content is dynamic; every transactional notification (shipped, delivered, review-request) is another link with its own attribution context.
The pattern that scales: a campaign in the shortener corresponds to a send in the ESP. The campaign owns the UTM template (utm_source=email, utm_medium=lifecycle, utm_campaign=cart-recovery-2026-05) and the destination URL pattern. The ESP integration mints a unique short link per recipient at send time, with the click_id baked in, and writes the click_id back to the recipient's profile so the open/click/conversion chain is observable end-to-end.
The bulk import endpoint matters here. Mining 100K short links via the standard POST /v1/links endpoint serialises against API rate limits even on Pro tier. The right tool is POST /v1/links/bulk with a CSV body - Elido validates every row, commits atomically (no half-imported sends), and returns the slug list keyed to the input row IDs so the ESP can match the slug back to the recipient.
For Klaviyo, Customer.io, and Iterable, the integration shape is a webhook that fires at send-finalisation: ESP posts the recipient list, the shortener mints the links, the response is posted back to the ESP for content-substitution into the email template. For Shopify Email and the Shopify Marketing app, the shape is similar but the substitution happens in the Liquid template rather than at send-finalisation.
The bulk import via Sheets tutorial covers the manual version; the API-driven version is documented in the API reference.
Stage 3: on-site conversion#
The shortener is not on the request path on-site. The click_id, however, has to make it onto the order record.
For Shopify specifically, the integration is straightforward. The PDP picks up ?elido_click= from the URL, the theme's app embed (or your theme code, or your Shopify Plus checkout extension) writes it to Shopify.checkout.attributes.elido_click_id so it persists into the order's note_attributes when the cart finalises. At order-paid webhook time, the click_id is available on the order payload and you forward the conversion server-side.
For headless setups (Hydrogen, Next.js commerce, Centra), the equivalent is writing the click_id to the cart's custom attribute via the storefront API at the moment of cart creation. The cart-to-order conversion preserves the attribute, and the order webhook delivers it to whatever back-end is doing the conversion forward.
What I see go wrong most often: the click_id is captured into a session cookie but not written to the order. Three days later, marketing reports say conversions are flat; one week later, a developer realises that the attribute was never plumbed through the checkout extension. Build the verification into the launch checklist: place a test order, watch the order-paid webhook, confirm the click_id is on the payload before flipping production traffic.
For the cookieless / ITP context - why this matters more in 2026 than it did in 2022 - see the click attribution after Safari ITP post and Apple's ITP 2.3 release notes directly.
Stage 4: post-purchase#
The order is placed. Now the data plane has to do two things: forward the conversion to the ad platforms server-side, and start the post-purchase customer journey with attribution intact.
Server-side conversion forwarding. This is where most of the recovered revenue lives. With Safari ITP and ad-blocker proliferation, the browser pixel misses 25-40% of conversions on a typical Shopify shop (the exact number depends on traffic mix; iOS-heavy shops are at the high end). Server-side forwarding to Meta's Conversions API, GA4 Measurement Protocol, and TikTok Events API recovers most of the gap.
The integration: the order-paid webhook fires, the back-end reads the click_id off the order, looks up the click_id in Elido (or trusts the one already attached), and POSTs a conversion to each connected platform. Elido's POST /v1/conversions endpoint accepts the click_id plus the conversion payload (value, currency, event_name=Purchase, hashed user identifiers) and fans out to whichever platforms the workspace has credentials for. The fan-out includes the SHA-256 hashing of the email and phone - required by Meta CAPI per the Conversions API requirements - and the retry/dedup logic so a webhook redelivery doesn't double-count.
The conversion forwarding guide walks through the credential setup; the server-side conversion tracking post goes deeper on the deduplication mechanics.
Post-purchase customer journey. The order confirmation email has links to the order status page, the support help centre, the brand's lifestyle content, an upsell or accessory recommendation. Each of these gets a short link in the campaign-mode mint pattern from Stage 2. The QR code on the package is the high-leverage one: the customer scans it after the package arrives, lands on a thank-you page, and converts to the loyalty programme or the second-purchase incentive.
For the QR code specifically, dynamic codes are the right call - you can update the destination after the package has shipped. The dynamic vs static QR post covers the trade-off.
Stage 5: retention and reactivation#
This is where shortener volume gets noisy. A reasonable Shopify shop running Klaviyo or Customer.io fires lifecycle messages on dozens of triggers per customer. Welcome series, abandoned cart, browse abandonment, post-purchase upsell, replenishment, win-back, birthday, VIP - each is a campaign in the marketing automation tool, and each campaign mints links at send time.
The pattern that holds: each lifecycle campaign in the ESP maps to a campaign in the shortener. The shortener campaign owns the UTM template; the ESP-side mint payload only varies by recipient and product. Analytics roll up by lifecycle stage. The marketing team can see "abandoned cart recovery email is generating 4.2% conversion at €0.14 per click", not "we've minted 380K links this month and don't know which fraction was abandoned cart".
The webhook integration for adds matters at this stage too. Klaviyo's Email Opened and Email Clicked events should join with Elido's click.created events at the analytics layer; for most teams, this lives in their warehouse (BigQuery, Snowflake, ClickHouse) where the join key is the click_id. Elido's ClickHouse export guide covers the warehouse-side ingestion shape.
Branded domain: the small lift that compounds#
Every channel above benefits from a branded domain. acme.click/spring-jeans-de outperforms bit.ly/3xKj9wZ on click-through-rate by a measurable margin - the Princeton link-trust study from 2019 puts the lift in the 12-31% range depending on industry, and the larger ecommerce vendors I've audited see numbers in the same range with their own A/B tests.
The branded domain does three things at once. It signals legitimacy on platforms that are increasingly skeptical of shortened URLs (LinkedIn now warns on bit.ly; Gmail's spam scoring penalises generic shorteners on certain template types). It gives you a domain you control in case your shortener vendor relationship sours. And it lets you run wildcards - *.acme.click for tenant-per-subdomain in a multi-brand portfolio - without raising support tickets per add.
Custom domains feature page covers the pricing tier; the operational walkthrough covers the DNS pointing and TLS-on-demand setup.
What goes wrong in production#
Three failure modes I see repeat across ecommerce shops.
Click_id not propagating through checkout. Already mentioned. Always test with a real order before launching.
Conversion forwarding without deduplication. The order-paid webhook fires, the conversion forwards to Meta and GA4. Then the merchant tag manager - which is still on the page - fires a browser-side conversion pixel for the same order. Both Meta and GA4 ingest, the conversion is double-counted, the budget allocator over-pulls. The fix is the deduplication identifier: Meta CAPI accepts an event_id, GA4 accepts a client_id, both will dedupe browser+server events with the same ID. Set the order ID as the event_id, the browser-side pixel sets the same value, both platforms dedupe. Meta's deduplication doc is the reference.
Retention windows misaligned. Marketing wants 24-month attribution windows for first-time buyers. Click events default to a 90-day retention in most analytics platforms. The first time someone runs a year-end LTV cohort analysis, the click_id-keyed conversion is gone and the report shows no attribution credit. Set the retention to match the attribution window from day one - Elido lets you configure it per-workspace; ClickHouse retention is set on the underlying table.
Procurement notes for ecommerce buyers#
Three things I'd flag specifically for ecommerce procurement teams.
EU residency. If your customer base is mostly EU, your shortener's hosting region matters for the Schrems II conversation. The GDPR for URL shorteners cornerstone covers the contractual specifics; the trust page is the procurement-facing artefact.
API rate limits. Bulk-mint volume during peak (Black Friday, holiday, brand collaboration drops) determines whether you'll see API rate-limit pages at the worst possible time. Make sure the limit on your tier accommodates your peak, not your average. Elido's rate limits are documented per-endpoint; the bulk-mint endpoint sustains 1,000 RPS on Pro and is uncapped on Business.
Shopify integration. As of writing, Elido has a published Shopify app under review. Until then, the integration is via the storefront API plus a simple Cloudflare Worker or Shopify Function that captures the click_id on landing. Customer.io, Klaviyo, and Iterable have published integrations.
For the platform-vs-platform comparison, the Bitly alternatives feature gap post covers the feature matrix; the Elido vs Bitly post covers the pricing arithmetic.
Read the cluster#
This is the cornerstone of the industries cluster. Sibling posts: URL shorteners for influencers and creators (lifestyle commerce overlap), URL shorteners for restaurants (QR-heavy use case), URL shorteners for SaaS (B2B parallel). The solutions/marketers page is the persona-facing surface; the Shopify deep-link guide is the operational walk-through for the click_id propagation pattern. For team workflows around campaigns and bulk-mint, the campaigns feature page covers the data model.