Amplitude

Open amplitude.com and sign in or create an account. Click 'Create Project' from the home screen, give it a name, and — critically — pay attention to the 'Data Residency' selector. Amplitude offers US data residency (the default) and EU data residency (for GDPR-focused organizations). This setting determines your base URL for all subsequent API calls and cannot be changed after project creation without migrating data. If you select EU, your ingestion URL is `https://api.eu.amplitude.com/2/httpapi`. If US, it is `https://api2.amplitude.com/2/httpapi`. After creating the project, go to Settings (gear icon) → Projects → click your project → General tab. Copy the 'API Key' field — this is the ingestion-only public key. Also note the 'Secret Key' below it — that credential is only for the Dashboard REST API and Export API, which must be called from a server, never from FlutterFlow. Keep the Amplitude project open in a separate tab so you can use User Look-Up for testing in Step 5.

In FlutterFlow, click the gear icon in the bottom-left navigation → 'App Constants'. Click '+ Add Constant', name it `amplitudeApiKey`, set the type to String, and paste your Amplitude API key. Click Save. This is an ingestion-only key — it can write events into your project but cannot read data, export cohorts, or query dashboards. It is safe to bundle in your compiled app just as a publishable Stripe key or a Mapbox API key would be. The Amplitude secret key is a completely different credential: it enables read access to your analytics data and must never leave your server environment. If you need EU data residency, also store the base URL string as a second constant named `amplitudeBaseUrl` with value `https://api.eu.amplitude.com` — this makes it easy to switch environments without hunting through API Call configurations.

Click 'API Calls' in the FlutterFlow left nav → '+ Add' → 'Create API Group'. Name the group 'Amplitude'. For the base URL: if you are a US-region project, enter `https://api2.amplitude.com`; if EU, enter `https://api.eu.amplitude.com`. Click 'Add Call', name it 'Track Event'. Set the method to POST and the endpoint path to `/2/httpapi`. Under the Headers tab, add: `Content-Type` = `application/json`. Under the Body tab, select 'JSON' and enter the body structure below as raw JSON. Use FlutterFlow's variable syntax `{{variableName}}` for the fields that will vary per call. Add these variables in the Variables tab: `apiKey` (String), `userId` (String), `eventType` (String), and `eventTime` (integer — milliseconds since epoch). In the body, set `api_key` to `{{apiKey}}`, and inside the events array set `user_id` to `{{userId}}`, `event_type` to `{{eventType}}`, and `time` to `{{eventTime}}`. Under Response & Test, click 'Test API Call' using your actual API key and a test user ID to verify the call returns HTTP 200 with body `{"code":200}`. Save the API group.

1{
2  "api_key": "{{apiKey}}",
3  "events": [
4    {
5      "user_id": "{{userId}}",
6      "event_type": "{{eventType}}",
7      "time": "{{eventTime}}",
8      "event_properties": {}
9    }
10  ]
11}

Now connect the Amplitude API Call to actual user interactions. Select a widget — for example, the main action button on your most important screen — and open the Actions panel on the right. Click '+ Add Action' → 'Backend/API Call' → Amplitude → Track Event. You will be asked to provide values for each variable defined in Step 3. Map them as follows: `apiKey` → App Constants → amplitudeApiKey; `userId` → App State → currentUserUid (if using FlutterFlow auth) or your own user ID state variable; `eventType` → set an inline value like `'button_tapped'` or a variable if the event name varies; `eventTime` → use a Custom Function that returns `DateTime.now().millisecondsSinceEpoch` as an integer. For the `userId` vs `device_id` distinction: Amplitude requires at least one identifier per event. For logged-in users, `user_id` is your authenticated user UID. For anonymous/pre-login users, you must supply a `device_id` instead. If you later log the user in, Amplitude automatically merges their pre-login `device_id` events with their post-login `user_id` events. To get a stable `device_id`, add a Custom Action using the `device_info_plus` pub.dev package to read the device's persistent identifier. For page-view events, click on the page background (not any widget), go to Actions → On Page Load, and add the same Amplitude Track Event call with event_type set to `'screen_viewed'` and an additional custom property for the screen name. Add the action to every key page in your app.

1// FlutterFlow Custom Function: getCurrentTimeMs
2// Return type: int
3// No arguments needed
4
5int getCurrentTimeMs() {
6  return DateTime.now().millisecondsSinceEpoch;
7}

Open your Amplitude project → click 'User Look-Up' in the left sidebar. Enter the `user_id` you used in your test (your authenticated UID or the test value you hardcoded). If the event was ingested successfully, you will see a timeline of events for that user within a few seconds to a minute. If User Look-Up shows 'No users found', go to Data → Ingestion Debugger (available in some plans) or check the Ingestion Monitor under Settings. Common reasons for zero events despite 200 responses: (1) you are sending to the US host but your project is in the EU region — check Settings → Data Residency and update the API Group base URL accordingly; (2) the event is missing both `user_id` and `device_id` — Amplitude returns a 400 `missing_field` error in the response body that you may have missed; (3) there is a property type mismatch (e.g., `time` sent as a string instead of a number). To protect the secret key for Dashboard/Export API calls: never add the Amplitude secret key to an API Call header or App Constant. If your app needs to pull cohort data or query the Dashboard REST API, build a Firebase Cloud Function that uses the secret key server-side and expose a simple endpoint to your FlutterFlow app. The FlutterFlow API Call targets your function URL, not Amplitude's API directly.

The API Call approach in Steps 1-5 gives you reliable event ingestion but lacks some features that the native Amplitude Flutter SDK provides out of the box: automatic session tracking (start/end of app sessions), offline event queuing (events captured when there is no network are sent when connectivity returns), and automatic device properties (OS version, device model, carrier). If your analytics requirements need these, you can wrap the `amplitude_flutter` pub.dev package in a FlutterFlow Custom Action. Click 'Custom Code' in the left nav → '+ Add' → 'Action'. Name it `initAmplitude`. In the Dependencies field, add `amplitude_flutter: ^3.16.0` (check pub.dev for the latest version). Add an argument `apiKey` (String). Paste the init code below. Add a second Custom Action named `trackAmplitudeEvent` with arguments `eventName` (String) and `userId` (String), containing the track code. Important: Custom Actions do not run in the FlutterFlow browser Run mode. You must test them by deploying to a real device via APK or using FlutterFlow's Local Run feature. Call `initAmplitude` once from your App's initialization action (on the first page's On Page Load, guarded by a 'first launch' check). Then call `trackAmplitudeEvent` wherever you previously called the API Call.

1// Custom Action: initAmplitude
2// Argument: apiKey (String)
3import 'package:amplitude_flutter/amplitude.dart';
4import 'package:amplitude_flutter/identify.dart';
5
6Future initAmplitude(String apiKey) async {
7  final Amplitude amplitude = Amplitude.getInstance();
8  await amplitude.init(apiKey);
9  await amplitude.trackingSessionEvents(true);
10  amplitude.setUserId(currentUserUid); // set from App State
11}
12
13// Custom Action: trackAmplitudeEvent
14// Arguments: eventName (String)
15Future trackAmplitudeEvent(String eventName) async {
16  final Amplitude amplitude = Amplitude.getInstance();
17  await amplitude.logEvent(eventName);
18}