# LinkSense Overview LinkSense is a dynamic link management platform for mobile and web apps. It creates a single short URL that routes each user to the best destination based on their device: open the iOS or Android app if installed, send them to the App Store or Play Store if not, and fall back to a web URL on desktop. ## What it does - **Smart device routing.** One link, correct destination per platform (iOS, Android, desktop). - **iOS Universal Links and Android App Links.** Opens the native app when installed; no intermediate browser redirect. - **Social media previews.** Serves Open Graph tags to crawlers (Slack, Discord, Twitter, WhatsApp, etc.) while still redirecting real users. - **Custom short domains.** Every project gets a `.linksense.net` URL, with optional custom apex/subdomain via CNAME. - **Analytics.** Click counts, device/browser/country breakdown, per-link performance. - **REST API.** Manage projects, links, and apps programmatically (Pro plan). ## Who it's for - iOS / Android developers who need device-aware deep links into their native apps. - Marketing teams running multi-platform campaigns who want a single shareable link. - SaaS products that need deep linking into their mobile apps from email, push notifications, or ads. ## Core concepts - **Project** — a container for links. Each project has a unique subdomain (e.g. `myapp.linksense.net`) and optionally one or more iOS and Android apps registered to it. - **Dynamic link** — a URL under a project subdomain that encodes the per-platform destination rules. - **iOS app / Android app** — registered identifiers (bundle ID, package name, team ID, SHA-256) used to enable Universal Links / App Links for that project. ## Plans - **Free (Starter)** — 1 project, up to 1,000 links, 7-day analytics history. - **Pro ($19.99/month)** — unlimited projects and links, full analytics history, REST API access, custom domains. 7-day money-back guarantee. - **Enterprise** — self-hosting, custom integrations, priority support. Contact `support@linksense.net`. ## Quick links - Sign up: https://linksense.net/register - Pricing: https://linksense.net/pricing - Docs: https://linksense.net/docs - API reference: https://linksense.net/docs/api - Support: support@linksense.net --- # Getting Started LinkSense is a dynamic link management platform for mobile and web apps. This page walks through creating an account, a project, and your first dynamic link in a few minutes. ## Prerequisites - A valid email address for account registration. - A destination URL for your first dynamic link. - Optionally, an iOS or Android app for deep-linking setup. ## Create your account 1. Visit https://linksense.net/register and enter your email and a password. 2. After registration you land on the dashboard. All new accounts start on the free Starter plan; you can upgrade to Pro at any time. ## Create your first project Projects are containers for your dynamic links. Each project gets its own subdomain. 1. From the dashboard, click **New Project**. 2. Enter a descriptive name (e.g. "My Mobile App"). 3. Pick a unique subdomain. It becomes part of every link URL: `myapp.linksense.net`. You can change it later from the project settings page, and your link URLs update to match. 4. Click **Create**. ## Create your first link 1. From the project dashboard, click **New Link**. 2. Give the link a name (internal, not visible to users) and optionally a custom path like `/summer-sale`. 3. Optionally enter a destination URL — only a name is required, and you can add or change the destination later. 4. (Optional) Configure platform-specific URLs for iOS, Android, and desktop. 5. (Optional) Add social preview title, description, and image. 6. Click **Create Link**. Copy the URL and share it. ## Test your link - Open it on your phone — verify it routes to the correct destination. - Open it on desktop — verify the fallback URL loads. - Paste it into Slack / Discord / Messages — verify the social preview card appears (if configured). - Check the analytics on the link details page for your test clicks. ## Next steps - [Dynamic Links](https://linksense.net/docs/dynamic-links.md) — advanced link configuration and device routing. - [iOS Deep Linking](https://linksense.net/docs/ios-deep-linking) — set up Universal Links for your iOS app. - [Android Deep Linking](https://linksense.net/docs/android-deep-linking) — set up App Links for your Android app. - [API Reference](https://linksense.net/docs/api.md) — automate link management from your backend. --- # Projects In LinkSense — a dynamic link management platform for mobile and web apps — projects are the top-level organizational unit. Each project is a container for dynamic links and has its own subdomain. You might have one project for your production app, one for a marketing campaign, and another for testing. Every dynamic link belongs to exactly one project. The project determines the subdomain in the link URL, the iOS / Android apps registered for deep linking, and the analytics dashboard view. ## Creating a project From the Dashboard, click **New Project** and provide: - **Project name** — a descriptive name (e.g. "My Mobile App"). - **Subdomain** — a unique subdomain used in every link URL. The subdomain can be changed later from the project settings page, and your link URLs update to match. Choose a clear subdomain — it becomes part of all your link URLs. The number of projects you can create depends on your plan. Free is 1 project; Pro is unlimited. ## Project settings From the project settings page you can: - Update the project name. - Manage the project's custom domain. - View project-level analytics. - Manage dynamic links within the project. To register iOS and Android apps for deep linking, use the project's Apps tab rather than the settings page. ## Subdomains Each project has a unique subdomain under the LinkSense root domain. Dynamic link URLs follow this format: ``` https://.linksense.net/ ``` Subdomains must be unique across all LinkSense users. They may contain lowercase letters, numbers, and hyphens. Reserved words (`app`, `api`, `www`, etc.) cannot be used. ## Deleting a project Deleting a project permanently removes all its dynamic links, app registrations, and analytics data. This is irreversible — any existing links using the project's subdomain stop working immediately. To delete: project settings → danger zone at the bottom → confirm by typing the project name. --- # Dynamic Links A LinkSense dynamic link is a single URL that behaves differently depending on how it's accessed. LinkSense is a dynamic link management platform for mobile and web apps. When someone clicks your link, LinkSense: 1. Detects the user's device type and operating system. 2. Checks whether the request is from a social-media bot (and serves preview metadata if so). 3. Routes the user to the appropriate destination — app, app store, or web URL. 4. Records analytics for the click. You can share the same link in social media, email, push notifications, or print, and each user still gets the best experience for their device. ## Creating a link 1. From your project, click **New Link**. 2. Set a name (the only required field) and an optional custom path. 3. Configure routing: attach a registered iOS and/or Android app, set per-platform fallback URLs, and set a desktop URL. 4. Optionally add social preview metadata. 5. Save and copy the generated URL. ## Device routing ### iOS Attach a registered iOS app (`ios_app_id`) to open or deep-link the app via Universal Links, or to send users to the App Store when the app isn't installed (requires a registered iOS app with bundle ID and team ID). Set `ios_fallback_url` to control where iOS users go when no app target applies. ### Android Attach a registered Android app (`android_app_id`) to open or deep-link the app via App Links, or to send users to the Play Store when the app isn't installed (requires a registered Android app with package name and SHA-256 fingerprint). Set `android_fallback_url` to control where Android users go when no app target applies. ### Desktop Desktop users (Windows, macOS, Linux) go to the `desktop_url`. If no target applies to a user's device, the project's landing page is shown. ## Custom paths Each link can have a readable custom path: ``` https://your-subdomain.linksense.net/summer-sale ``` Custom paths must be unique within a project. They may contain lowercase letters, numbers, and hyphens. If omitted, a random short code is generated. Certain paths are reserved (system paths such as `.well-known` and similar internal routes) and cannot be used. ## Fallback URLs Fallback URLs are configured per platform: `ios_fallback_url` and `android_fallback_url` control where users go when the attached app can't be opened. Desktop users go to `desktop_url`. None of these are required — if no target applies to a user's device, the project's landing page is shown. ## Social previews When a social-media bot crawls the link, LinkSense serves an HTML page with Open Graph tags instead of redirecting. This lets platforms render a rich preview card. Each link can have its own social preview title, description, and image. ## Field reference | Field | Type | Required | Description | |---|---|---|---| | `name` | string | yes | Internal name for the link (not shown to users). | | `custom_path` | string | no | Custom path slug; auto-generated if empty. | | `desktop_url` | url | no | Destination URL for desktop users. | | `ios_app_id` | string | no | UUID of a registered iOS app in this project. | | `android_app_id` | string | no | UUID of a registered Android app in this project. | | `ios_fallback_url` | url | no | Fallback URL when the iOS app is not installed. | | `android_fallback_url` | url | no | Fallback URL when the Android app is not installed. | | `social_title` | string | no | Title for social preview cards. | | `social_description` | string | no | Description for social preview cards. | | `social_image_url` | url | no | Image URL for social preview cards. | --- # Social Previews In LinkSense — a dynamic link management platform — every dynamic link can carry custom social preview metadata. When a social-media crawler (Slack, Discord, Twitter/X, Facebook, LinkedIn, WhatsApp, Telegram, Pinterest, etc.) fetches a LinkSense URL, the platform serves an HTML page with Open Graph and Twitter Card tags instead of redirecting. Real users still get redirected normally to the right destination for their device. ## Configure a preview When creating or editing a dynamic link you can set: - `social_title` — headline shown in the preview card. - `social_description` — short blurb under the title. - `social_image_url` — image displayed in the preview card. For best results set all three. Missing fields cause platforms to fall back to generic metadata or show no preview at all. ## Open Graph tags emitted When a crawler hits the link, LinkSense generates: | Tag | Source | |---|---| | `og:title` | `social_title` | | `og:description` | `social_description` | | `og:image` | `social_image_url` | | `og:url` | the canonical URL of your dynamic link | | `twitter:card` | `summary_large_image` (when an image is provided) | | `twitter:title` | `social_title` | | `twitter:description` | `social_description` | | `twitter:image` | `social_image_url` | ## Bot detection LinkSense detects social-media crawlers via User-Agent and serves them HTML with the meta tags above. Regular users hit the device-routing logic instead. No special configuration is needed — bot detection is automatic. ## Image guidelines - **Recommended size**: 1200 × 630 pixels. - **Aspect ratio**: 1.91:1. - **Format**: JPEG or PNG. - **File size**: under 5 MB (smaller is faster). - **Composition**: keep important content centered — platforms may crop edges. - **URL**: must be a publicly accessible HTTPS URL. Platforms won't load HTTP or authenticated images. ## Test previews Use platform-specific tools to verify how a card will render: - **Facebook**: Sharing Debugger at developers.facebook.com. - **Twitter/X**: Card Validator at cards-dev.twitter.com. - **LinkedIn**: Post Inspector at linkedin.com/post-inspector. Social platforms aggressively cache preview data. If you update settings and the old preview keeps showing, use the platform's debugger to clear the cache and re-fetch. --- # Landing Pages A landing page is the page visitors see when they open one of your dynamic links on desktop — where there is no app to deep-link into. Each project gets one landing page that showcases your app and points people to the App Store and Google Play. The page is generated from the app details you have already added to the project. There is no AI and no drag-and-drop builder — the layout is fixed and fully deterministic, so the same app data always produces the same page. You can still hand-edit the HTML afterward. ## Where it fits On phones, your links open the app (or send the visitor to the store). On desktop there is nothing to open, so the visitor lands on this page instead. It is the desktop destination for every dynamic link in the project. ## Requirements A landing page is built from the project's apps, so you need at least one iOS or Android app added to the project with its details filled in. If the project has no apps, generating fails with "Add an iOS or Android app to the project before generating a landing page." The richer your app data, the richer the page. Every section degrades gracefully — a missing icon, no screenshots, or only one store link simply hides that part rather than breaking the layout. ## Generating your landing page 1. From your project, open the **Landing page** tab. 2. Click **Generate landing page**. LinkSense reads the project's first iOS app and first Android app and builds the page from their stored details. 3. The page goes live at your project's link host immediately. Open it in a new tab to preview it. The generator pulls the following from your apps, and also creates a QR code pointing to your link host so visitors can scan to install: - **App name** and **icon** (a colored monogram is used if there is no icon). - **Description** — the app's tagline / short description, falling back to the full description. - **Screenshots** — combined from your iOS and Android apps. - **Store links** — App Store and Google Play URLs. ## What's on the page Every landing page follows the same structure. Sections with no data are left out: - **Header** — app icon and name, plus a "Get the app" button. - **Hero** — app icon, name, your link host, the description, store badges, and a scan-to-install QR code. - **Screenshots** — a horizontal carousel (hidden if you have no screenshots). - **Get the app** — a band repeating the store badges and QR code. - **Footer** — links to your Privacy and Terms pages (shown only when those pages exist) and a small "Page by LinkSense" credit. The page automatically adapts to the visitor's system light/dark theme — no configuration needed. ## Editing the HTML The generated page is plain, self-contained HTML. Click **Edit** to open a full-screen source editor with a live preview you can toggle between desktop and mobile widths. When you save, the HTML is sanitized on the server, so unsafe markup is stripped automatically. ## Regenerating Regenerate whenever you update your app details — new screenshots, a new icon, or an updated description — to rebuild the page from the latest data. **Regenerating overwrites manual edits.** It rebuilds the page from your app data and replaces any HTML you edited by hand. Copy your current HTML first — the regenerate dialog offers a one-click copy button before you confirm. ## Hosting & URL Your landing page is served at the root of the project's link host — your branded subdomain (e.g. `myapp.linksense.net`) or your custom domain once it is verified (Pro). It is served from the edge, so it loads quickly worldwide and stays up independently of the dashboard. ## Next steps - [Dynamic Links](https://linksense.net/docs/dynamic-links) — configure how your links route across iOS, Android, and desktop. - [Projects](https://linksense.net/docs/projects) — manage projects, apps, and your link host subdomain. - [iOS Deep Linking](https://linksense.net/docs/ios-deep-linking) — set up Universal Links so links open your iOS app. - [Android Deep Linking](https://linksense.net/docs/android-deep-linking) — set up App Links so links open your Android app. --- # Analytics LinkSense — a dynamic link management platform — automatically tracks every click on every dynamic link. Analytics are available at the individual link level and the project level. Click tracking begins as soon as a link receives its first visit; no instrumentation is needed. Analytics are available on all plans. The **Free** plan retains the last **7 days** of history; the **Pro** plan keeps the **full history** with no retention limit. ## Click tracking Each click records: - **Timestamp** — when the click occurred. - **Device type** — mobile, tablet, desktop. - **Operating system** — iOS, Android, Windows, macOS, Linux, etc. - **Browser** — Chrome, Safari, Firefox, Edge, etc. - **Country** — geographic location resolved from IP. - **Referrer** — where the click came from, when available. LinkSense does not store personally identifiable information. IP addresses are used for country lookup only and are not retained in raw form. ## Device & browser breakdown The dashboard shows clicks broken down by device type and browser so you can see which platforms your audience uses. Device categories include mobile phones, tablets, and desktop computers. Browser detection covers all major browsers with version information. ## Geographic data Country-level breakdown is computed from the client IP at click time. Use it to spot where your audience is concentrated and to inform localization or paid-media targeting. ## Link-level analytics Each dynamic link has its own analytics view from the link details page: - Total click count - Clicks over time (chart) - Device-type distribution - Browser distribution - Top countries Date range selector: 7 days, 30 days, 90 days. Free users are limited to 7 days; 30/90-day ranges are Pro features. ## Project-level analytics Project-level analytics aggregate data across all links within a project — a high-level view of how your entire link portfolio is performing. Access from the project dashboard. ## See also - [Dynamic Links](https://linksense.net/docs/dynamic-links.md) - [Projects](https://linksense.net/docs/projects.md) - [Pricing](https://linksense.net/pricing.md) --- # iOS Deep Linking LinkSense — a dynamic link management platform — supports iOS Universal Links so a tap on a LinkSense URL opens directly in your iOS app instead of Safari. iOS uses the Apple App Site Association (AASA) file to verify the link belongs to your app. LinkSense hosts the AASA automatically; you only need to register your app and configure your Xcode project. ## Prerequisites - An [Apple Developer account](https://developer.apple.com/account) with active membership. - Your app's Bundle Identifier (e.g. `com.example.myapp`). - Your Apple Team ID (10-character alphanumeric like `A1B2C3D4E5`). - A LinkSense project with a subdomain. ## Register your iOS app In the LinkSense dashboard, open your project's **Apps** tab and add an iOS app. Provide: - **App name** — friendly label. - **Bundle ID** — your app's Bundle Identifier. - **Team ID** — your Apple Developer Team ID. - **App Store ID** — found in App Store Connect under App Information; used for fallback redirects when the app isn't installed. ## Apple App Site Association (AASA) LinkSense generates and hosts the AASA file at: ``` https://.linksense.net/.well-known/apple-app-site-association ``` The file has the structure: ```json { "applinks": { "apps": [], "details": [ { "appIDs": ["TEAM_ID.com.example.myapp"], "paths": ["*"] } ] } } ``` The file updates automatically whenever you add or remove iOS apps from the project. No manual hosting. ## Configure your Xcode project 1. Open your project in Xcode. 2. Select your app target → **Signing & Capabilities**. 3. Click **+ Capability** → add **Associated Domains**. 4. Add an entry with your LinkSense subdomain. Your entitlements file should include: ```xml com.apple.developer.associated-domains applinks:your-subdomain.linksense.net ``` ## Test Universal Links 1. Install your app on a physical device — Universal Links don't work in the simulator. 2. Open Notes or Messages and paste your dynamic link URL. 3. Tap the link — it should open directly in your app. 4. If the link opens in Safari instead, long-press it and look for an **Open in [App]** option. Universal Links never trigger if you type the URL into Safari's address bar. They only fire from taps on links in other apps (Notes, Mail, Messages, third-party apps). ## See also - [Android Deep Linking](https://linksense.net/docs/android-deep-linking.md) - [Dynamic Links](https://linksense.net/docs/dynamic-links.md) - Apple's guide: [Supporting Universal Links in Your App](https://developer.apple.com/documentation/xcode/supporting-universal-links-in-your-app) --- # Android Deep Linking LinkSense — a dynamic link management platform — supports Android App Links so a tap on a LinkSense URL opens directly in your Android app instead of Chrome. Android uses the Digital Asset Links file (`assetlinks.json`) to verify the link belongs to your app. LinkSense hosts this file automatically; you only need to register your app and add an intent filter. ## Prerequisites - Your app's package name (e.g. `com.example.myapp`). - Your app's SHA-256 signing certificate fingerprint. - A Google Play Developer account (if publishing to the Play Store). - A LinkSense project with a subdomain. ## Register your Android app In the LinkSense dashboard, open your project's **Apps** tab and add an Android app. Provide: - **App name** — friendly label. - **Package name** — your app's package name. - **SHA-256 fingerprint** — your signing certificate fingerprint (one or more entries). - **Play Store link** — optional; used for fallback redirects when the app isn't installed. ### Finding your SHA-256 fingerprint - **Production apps**: [Google Play Console](https://play.google.com/console) → Setup → App signing — copy both the upload and app signing key fingerprints. - **Debug builds**: `keytool -list -v -keystore your-keystore.jks` ## Digital Asset Links LinkSense generates and hosts the assetlinks.json file at: ``` https://.linksense.net/.well-known/assetlinks.json ``` Structure: ```json [ { "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.example.myapp", "sha256_cert_fingerprints": [ "AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:..." ] } } ] ``` The file updates automatically when you add or remove Android apps from the project. ## Configure your Android app Add an intent filter with `android:autoVerify="true"` to your `AndroidManifest.xml`: ```xml ``` `autoVerify` tells Android to fetch your Digital Asset Links file at install time and verify it belongs to your app. ## Test App Links 1. Install your app on a physical device or emulator. 2. Verify the assetlinks.json with Google's Statement List Generator. 3. Open a messaging app and paste your dynamic link URL. 4. Tap the link — it should open directly in your app. You can also force-test via ADB: ```bash adb shell am start -a android.intent.action.VIEW \ -d https://your-subdomain.linksense.net/your-path ``` If you change the Digital Asset Links configuration after install, users may need to reinstall the app or wait for the system to re-verify. ## See also - [iOS Deep Linking](https://linksense.net/docs/ios-deep-linking.md) - [Dynamic Links](https://linksense.net/docs/dynamic-links.md) --- # Plans & Billing LinkSense — a dynamic link management platform — has two self-serve plans (Free and Pro) plus an Enterprise tier. This page covers the limits, how to upgrade, and how to manage your subscription. For live pricing and plan details see [https://linksense.net/pricing](https://linksense.net/pricing.md). ## Available plans - **Free (Starter)** — $0. 1 project, up to 1,000 links, 7-day analytics history, basic support. Free forever, no credit card required. - **Pro** — $19.99 / month. Unlimited projects and links, full analytics history, REST API access, priority email support. 7-day money-back guarantee. Cancel anytime. - **Enterprise** — custom. Self-hosting, white-label, custom integrations, advanced security. Contact `support@linksense.net`. ## Plan limits Each plan caps these resources: - **Projects** — total projects you can create. - **Dynamic links per month** — total link creations within a billing period. - **iOS apps per project** — number of iOS app registrations. - **Android apps per project** — number of Android app registrations. - **Analytics history** — how far back you can view click data. When you hit a limit you'll see an inline upgrade prompt explaining the restriction. ## Upgrading to Pro Upgrade from **Dashboard → Settings → Billing**, or from any in-app upgrade prompt. Checkout runs through Paddle (our payment processor); you'll be redirected to Paddle's secure checkout and back when complete. New limits take effect immediately. Existing projects and links are unaffected — you simply gain the ability to create more. ## Managing your subscription In **Dashboard → Settings → Billing** you can: - View your current plan and renewal date. - Update your payment method. - View billing history and download invoices. - Cancel your subscription. Most billing operations are handled through the Paddle customer portal, accessible from the same page. ## Cancellation Cancelling Pro keeps you on Pro features until the end of the current billing period; after that your account reverts to the Free plan. If you have more resources than the Free plan allows (e.g. multiple projects), they remain accessible — you just can't create new ones until you're back within Free limits. ## Free trial Pro includes a 7-day money-back guarantee. If you upgrade and decide it's not for you, contact `support@linksense.net` within 7 days for a full refund. ## See also - [Pricing](https://linksense.net/pricing.md) - [Getting Started](https://linksense.net/docs/getting-started.md) --- # API Reference Manage projects, dynamic links, and app registrations programmatically via the LinkSense REST API. Available on the Pro plan. Machine-readable OpenAPI 3.1 spec: https://linksense.net/openapi.json ## Base URL ``` https://linksense.net/api/v1 ``` ## Authentication Every request requires an API key sent as a Bearer token: ``` Authorization: Bearer ls_live_your_api_key_here ``` Generate and manage API keys at **Dashboard → Settings → API Keys**. Treat them like passwords — never commit them or expose them in client-side code. ## Rate limits - 60 requests per minute per API key. - Exceeding the limit returns `429 Too Many Requests`. Every response includes: | Header | Description | |---|---| | `X-RateLimit-Limit` | Maximum requests per window. | | `X-RateLimit-Remaining` | Requests remaining in the current window. | | `X-RateLimit-Reset` | Unix timestamp (seconds) when the window resets. | ## Response format Success — results are wrapped in a `data` envelope: ```json { "data": { "id": "abc123", "name": "My Project", "subdomain": "my-project", "created_at": "2026-01-01T00:00:00Z" } } ``` Errors use an `error` envelope with `code` (machine-readable) and `message` (human-readable): ```json { "error": { "code": "NOT_FOUND", "message": "The requested resource does not exist." } } ``` ## Error codes | Code | HTTP | Description | |---|---|---| | `INVALID_INPUT` | 400 | Request body or query parameter validation failed. | | `FORBIDDEN_FIELD` | 400 | The request included a field that isn't allowed. | | `UNAUTHORIZED` | 401 | API key missing, invalid, or revoked. | | `AUTH_REQUIRED` | 401 | Authentication is required for this request. | | `ACCESS_DENIED` | 403 | The resource belongs to another account, or access was denied. | | `FORBIDDEN_PLAN` | 403 | Your plan doesn't include this feature. Upgrade to Pro for API access. | | `FORBIDDEN_CROSS_SCOPE` | 403 | The referenced resource belongs to a different project or account. | | `NOT_FOUND` | 404 | Resource does not exist. | | `IOS_APP_NOT_FOUND` | 404 | `ios_app_id` does not exist in the project. | | `ANDROID_APP_NOT_FOUND` | 404 | `android_app_id` does not exist in the project. | | `SUBDOMAIN_TAKEN` | 409 | Subdomain already in use by another project. | | `CUSTOM_PATH_EXISTS` | 409 | A link with this custom path already exists in the project. | | `SLUG_EXISTS` | 409 | A resource with this slug already exists. | | `BUNDLE_ID_EXISTS` | 409 | An iOS app with this bundle ID already exists in the project. | | `PACKAGE_NAME_EXISTS` | 409 | An Android app with this package name already exists in the project. | | `LINKED_REFERENCES` | 409 | App can't be deleted because dynamic links still reference it. | | `RATE_LIMITED` | 429 | Rate limit exceeded. Wait until the window resets. | ## Endpoints All endpoints are scoped to the authenticated account. ### Projects - `GET /projects` — list projects. - `POST /projects` — create a project. - `GET /projects/{projectId}` — fetch a project. - `PUT /projects/{projectId}` — update a project. - `DELETE /projects/{projectId}` — delete a project. ### Dynamic links - `GET /projects/{projectId}/links` — list links in a project. - `POST /projects/{projectId}/links` — create a link. - `GET /projects/{projectId}/links/{linkId}` — fetch a link. - `PUT /projects/{projectId}/links/{linkId}` — update a link. - `DELETE /projects/{projectId}/links/{linkId}` — delete a link. ### iOS apps - `GET /projects/{projectId}/ios-apps` — list iOS apps registered to the project. - `POST /projects/{projectId}/ios-apps` — register an iOS app. - `GET /projects/{projectId}/ios-apps/{appId}` — fetch an iOS app. - `PUT /projects/{projectId}/ios-apps/{appId}` — update an iOS app. - `DELETE /projects/{projectId}/ios-apps/{appId}` — delete an iOS app. ### Android apps - `GET /projects/{projectId}/android-apps` — list Android apps registered to the project. - `POST /projects/{projectId}/android-apps` — register an Android app. - `GET /projects/{projectId}/android-apps/{appId}` — fetch an Android app. - `PUT /projects/{projectId}/android-apps/{appId}` — update an Android app. - `DELETE /projects/{projectId}/android-apps/{appId}` — delete an Android app. ## Quick example ```bash curl -H "Authorization: Bearer ls_live_abc123..." \ https://linksense.net/api/v1/projects ``` See https://linksense.net/docs/api/endpoints for full request/response payloads for each endpoint. --- # Firebase Dynamic Links Migration Migrate your dynamic links from Firebase to LinkSense. ## Why migrate Google deprecated Firebase Dynamic Links in August 2025. Existing links continue to resolve, but the service is no longer maintained and no new features will ship. LinkSense is a modern, actively-developed replacement with all the capabilities you relied on, plus real-time analytics, a cleaner dashboard, and flexible pricing. ## Migration overview 1. **Create a LinkSense account** — sign up and verify your email. 2. **Set up a project** — pick a subdomain. `yourapp.page.link` becomes `yourapp.linksense.net`. 3. **Register your apps** — add your iOS and Android apps with the same Bundle ID, Team ID, package name, and SHA-256 fingerprints you used in Firebase. 4. **Recreate your dynamic links** — matching the routing rules, fallback URLs, and social-preview settings. 5. **Update app configuration** — Associated Domains (iOS) and intent filters (Android) point to the new subdomain. 6. **Update link references** — replace Firebase URLs in marketing materials, emails, and hardcoded references. You can run Firebase and LinkSense in parallel during migration. Keep Firebase links live while you set up and test LinkSense, then switch. ## Feature comparison | Feature | Firebase | LinkSense | |---|---|---| | Device routing (iOS / Android / Desktop) | Yes | Yes | | Custom short links | Yes | Yes | | Social media previews | Yes | Yes | | Universal Links (iOS) | Yes | Yes | | App Links (Android) | Yes | Yes | | Click analytics | Yes | Yes | | Geographic analytics | No | Yes | | Browser & device breakdown | Limited | Yes | | Custom subdomains | Via hosting | Built-in | | Active development | Deprecated | Yes | ## Concept mapping | Firebase | LinkSense | |---|---| | Firebase project | Project | | URL prefix (e.g. `yourapp.page.link`) | Subdomain (e.g. `yourapp.linksense.net`) | | Dynamic link | Dynamic link | | Deep link URL | Fallback URL / per-platform URLs | | Social tag parameters | Social preview settings (title, description, image) | ## App configuration changes - **iOS** — update the Associated Domains entitlement: ``` applinks:yourapp.page.link → applinks:yourapp.linksense.net ``` - **Android** — update the intent filter host: ```xml android:host="yourapp.page.link" → android:host="yourapp.linksense.net" ``` ## Support Email `support@linksense.net` for migration help or enterprise self-hosting. See also: - [Getting Started](https://linksense.net/docs/getting-started.md) - [Dynamic Links](https://linksense.net/docs/dynamic-links.md) - [iOS Deep Linking](https://linksense.net/docs/ios-deep-linking) - [Android Deep Linking](https://linksense.net/docs/android-deep-linking) --- # Pricing LinkSense has two self-serve plans plus an enterprise tier. ## Free (Starter) — $0 - 1 project - Up to 1,000 links - Smart device detection & routing - iOS & Android app linking - Social media previews - Custom short domains - 7-day analytics history - Email support Free forever. No credit card required. ## Pro — $19.99 / month - Unlimited projects - Unlimited links - Smart device detection & routing - iOS & Android app linking - Social media previews - Custom short domains - Full analytics history - Deferred deep linking (mobile install attribution) - REST API access - Email support 7-day money-back guarantee. Cancel anytime. Secure checkout via Paddle. ## Enterprise — custom - Self-hosting options - Custom feature development - Priority support - White-label solutions - Enterprise integrations - Advanced security features Contact `support@linksense.net`. ## Notes - TLS encryption everywhere; GDPR compliant. - No lock-in — export your data at any time. - See https://linksense.net/pricing for the live pricing page.