Events & Conversions

Track and analyze in-app events from your mobile SDK to understand user behavior after they click your links.

Overview

The Events dashboard shows in-app events sent by your mobile SDK via trackEvent() and trackRevenue(). This gives you visibility into what users do after they install your app through a LinkForty link:

• Event volume - Total events, unique event types, and daily counts
• Revenue tracking - Aggregate revenue from trackRevenue() calls
• Top events - Most frequent event types at a glance
• Event timeline - Events over time as an area chart
• Event feed - Paginated table with event names, properties, and attributed links
• CSV export - Download raw event data for external analysis

Cloud Only

The Events dashboard is available on Pro and Unlimited plans. Free tier users see an upgrade prompt. Paid plans include real-time auto-refresh — the dashboard polls for new events every 30 seconds so you see data as it arrives.

How Events Flow

1. Your mobile app calls LinkForty.trackEvent() or LinkForty.trackRevenue()
2. The SDK sends the event to POST /api/sdk/v1/event with the install ID
3. The event is stored in the in_app_events table with its name, properties, and timestamp
4. The Events dashboard queries this data scoped to your organization

Events are linked to your organization through the install attribution chain: each event has an installId, which maps to a link click, which belongs to your organization.

Dashboard Layout

Stat Cards

Four summary metrics across the top:

Metric	Description
Total Events	All events tracked in the selected time range
Unique Events	Number of distinct event names
Events Today	Events received since midnight (UTC)
Revenue	Sum of revenue from trackRevenue() calls

Time Range Filter

Filter all data by time period: 7 days, 30 days, 90 days, or 1 year. Changing the time range updates stat cards, charts, and the event table.

Event Name Filter

Filter by a specific event type (e.g., only show purchase events). The dropdown is populated from your actual event data.

Charts

• Events Over Time (left, 2/3 width) - Area chart showing daily event counts
• Top Events (right, 1/3 width) - Horizontal bar chart of the 10 most frequent event types

Event Feed Table

A paginated table showing individual events:

Column	Description
Event Name	The event type (e.g., purchase, signup)
Properties	Key-value badges showing the event's custom data
Link	The short code of the attributed link, or "Organic"
Timestamp	Relative time (e.g., "2m ago", "Yesterday")

Tracking Events

Already have the SDK installed? This prompt adds sign-up, purchase and screen events at the right places in your app:

Send in-app events from the app

Signup, purchase and activation events from an app that already has the SDK, with revenue and currency, plus screen views for the funnel.

Show the prompt

I use LinkForty (https://linkforty.com), a deep-linking and mobile attribution platform: short links that route each click to the app, the app store or the web, and record clicks, installs and in-app events per link.

Before writing any code, read the LinkForty documentation index at https://docs.linkforty.com/llms-full.txt and the pages listed under "Docs" below. Work from what the docs say, not from assumptions about how similar products work. If something you need is not in the docs or in this prompt — an ID, a token, a URL — stop and ask me for it rather than inventing a placeholder that looks real.

## Task: send in-app events from this app to LinkForty

The LinkForty SDK is already installed and initialized in this app, and installs are being attributed. What is missing is everything after the install: the sign-ups, purchases and key actions that turn an install count into a funnel. Add event tracking so those moments are recorded against the install and the link that produced it.

If the SDK is **not** in this app, stop and tell me — installing it is a separate task with its own prompt.

## Values

- **App token**: already in the app's SDK initialization (it starts with `at_`; the dashboard shows it under Workspace Settings → App Token). Do not add it a second time or move it.
- **Event names**: chosen with me in step 2. Short, stable, lower_snake_case.
- **Money**: amount as a number plus an ISO 4217 currency code (`'USD'`), through the SDK's revenue method — never a formatted string.

## How to work

1. **Look before you change anything.** Identify the framework, its version, the navigation/router library and where the app initializes at launch. List the screens (routes) you found, and **ask me which screen each incoming link should open and what parameter it needs** — for example "a link with `productId` opens the product screen". Wait for my answer before editing; do not guess routes.
2. **Work on a new git branch.** If the working tree has uncommitted changes, stop and tell me instead of building on top of them.
3. **Follow the docs pages named below, not memory.** Package names, method names and config keys come from those pages; LinkForty's SDKs are not the same as other attribution SDKs you may know.
4. **Do not invent values.** Anything in "Values" that says "ask me" is something you ask for. Never commit a token to source.
5. **Keep the app working without a link.** A launch with no matching click must behave exactly as before: no crash, no error surfaced to the user, no blocked start-up.
6. **Finish with a summary**: every file you changed and why; the manual steps that remain for me (Apple Team ID and bundle ID, Play signing SHA-256 fingerprint, store listing, a rebuild and reinstall) and where in the LinkForty dashboard each one goes (Workspace Settings → App Configuration); and anything you were unsure about.
7. **Verify.** Run the app once, then check the LinkForty dashboard: the SDK Doctor badge in the sidebar (https://docs.linkforty.com/guides/attribution/sdk-health) should report the SDK as installed. If the MCP server is available, create a test link with `create_link` and open it on a device or simulator; the click and the deep link should reach the screen we agreed on.

## Steps

1. **Find the SDK.** Locate where LinkForty is initialized (`init` / `initialize`) and which package it is — `@linkforty/mobile-sdk-react-native`, `@linkforty/mobile-sdk-expo`, `LinkFortySDK` (Swift), `com.linkforty.sdk` (Kotlin) or `linkforty_flutter`. Every event goes through that same instance so it attaches to the install; never create a second one.
2. **Find the moments that matter** and list them with file and line: account created, onboarding finished, the first key action (whatever "activated" means in this app), purchase or subscription, and the two or three screens a new user must reach. **Ask me which to track and what to call each** before writing anything. Names are short, stable, lower_snake_case — `signup`, `onboarding_completed`, `purchase` (https://docs.linkforty.com/guides/analytics/events#event-naming-conventions). Not one event per tap.
3. **Fire each event once, at completion.** On the success path — after the account exists, after the payment is confirmed — not when a screen appears or a button is rendered. Guard against double-firing on re-render, retry or resume.
4. **Use the platform's own methods** from the SDK page (https://docs.linkforty.com/guides/analytics/events#custom-events): the track-event method for plain events with a small flat properties object; the revenue method — `trackRevenue(amount, currency, …)` — for anything with money, so the dashboard can sum it per currency (https://docs.linkforty.com/guides/analytics/events#revenue-events). No personal data in properties: no names, emails, phone numbers, precise location.
5. **Add screen views for the funnel** (https://docs.linkforty.com/guides/analytics/app-analytics): on React Native and Expo, prefer `autoTrackNavigation` with the app's `navigationRef` (screen names only — the default); on Android with Jetpack Navigation, `LinkFortyNavObserver`; otherwise `trackScreenView('ScreenName')` on the handful of screens from step 2. Never inside a render function or a hot loop — on navigation, or in the screen's appear/mount hook.
6. **Keep the app unaffected.** Event calls must not block the UI or throw into user code; the SDK queues offline and retries, so do not add your own retry layer.
7. **Verify** by running the app through the agreed flow once, then checking the LinkForty dashboard: the events on the Events dashboard, attached to the install; a purchase with its amount and currency; screens in the screen flow; and SDK Doctor showing events flowing (https://docs.linkforty.com/guides/attribution/sdk-health).

## Docs

- Events guide — custom events, revenue events, naming: https://docs.linkforty.com/guides/analytics/events
- App analytics and screen flow: https://docs.linkforty.com/guides/analytics/app-analytics
- Event Library (what the dashboard expects a name to mean): https://docs.linkforty.com/guides/analytics/event-library
- Your platform's SDK page, "Track Events" / "Track Screen Views": https://docs.linkforty.com/sdks/react-native#track-events · https://docs.linkforty.com/sdks/expo#track-events · https://docs.linkforty.com/sdks/ios#track-events · https://docs.linkforty.com/sdks/android#track-events · https://docs.linkforty.com/sdks/flutter#track-events

## Done when

- Each agreed event fires exactly once at completion, from the existing SDK instance.
- A purchase reports its amount and currency through the revenue method.
- Screen views arrive for the agreed screens without touching render paths.
- The events show in the LinkForty dashboard attached to the install, and SDK Doctor reports events flowing.

When you are done, tell me: exactly which files changed and why, how I can verify it worked end to end (what to tap or run, and what I should see in the LinkForty dashboard), and anything you were unsure about.

Custom Events

Track any named event with optional properties:

import LinkForty from '@linkforty/mobile-sdk-react-native';

// Track a purchase
LinkForty.trackEvent('purchase', {
  productId: 'sku-123',
  category: 'electronics',
  value: 49.99,
});

// Track a signup
LinkForty.trackEvent('signup', { method: 'google' });

// Track a screen view
LinkForty.trackEvent('screen_view', { screen: 'product_detail' });

Revenue Events

Use trackRevenue() for monetary events. This method ensures a consistent format across all SDKs so the dashboard can aggregate revenue:

// Track a $29.99 USD purchase
LinkForty.trackRevenue(29.99, 'USD', {
  productId: 'sku-123',
  orderId: 'order-456',
});

Revenue events are stored with:

• Event name: revenue
• Event data: { revenue: 29.99, currency: "USD", ...properties }

The Revenue stat card on the dashboard sums the revenue field from all events named revenue in the selected time range.

Event Naming Conventions

Use consistent, lowercase event names for clean analytics:

Convention	Example	Avoid
snake_case	add_to_cart	AddToCart, add-to-cart
Descriptive	purchase_completed	event1, pc
Namespaced	onboarding_step_3	step3

Exporting Event Data

Click Export CSV in the toolbar to download raw events. The export respects your current filters (time range and event name).

You can also export programmatically via the API:

curl "https://api.linkforty.com/api/analytics/events/export?days=30&format=csv" \
  -H "Authorization: Bearer $LINKFORTY_API_KEY"

See the Event Analytics API Reference for all export options.

API Access

All dashboard data is available via the API for building custom reports or integrations:

Endpoint	Description
GET /api/analytics/events/overview	Stat cards and top events
GET /api/analytics/events/timeline	Daily event counts
GET /api/analytics/events/list	Paginated event feed
GET /api/analytics/events/names	Distinct event names with counts
GET /api/analytics/events/export	CSV/JSON export

See the full Event Analytics API Reference.

Best Practices

1. Track meaningful events - Focus on events that represent user value (purchases, signups, content views) rather than low-level interactions
2. Include useful properties - Add context like product IDs, categories, or amounts to make your data actionable
3. Use trackRevenue() for money - Don't track revenue as a regular event; use the dedicated method so the dashboard can aggregate it
4. Keep event names consistent - Standardize on snake_case and use the same name across platforms
5. Don't over-track - Sending hundreds of events per session adds noise. Track 5-15 key events per user journey

Limitations

• Events from organic installs (no link attribution) are not shown in the dashboard for v1. Only events from installs attributed to a LinkForty link appear.
• The Revenue stat assumes all SDKs use the standard trackRevenue() convention. Manually tracked revenue events with different field names won't be aggregated.