Adobe Analytics

Before writing any FlutterFlow code, your Adobe admin needs to create a mobile property in Adobe Data Collection (formerly Experience Platform Launch) at experience.adobe.com → Data Collection → Tags → New Property. Set the platform to Mobile, give it a name that matches your FlutterFlow app, and save. Inside the property, go to the Environments tab and copy the App ID for the environment you want to target (Development, Staging, or Production) — it looks like a long alphanumeric string like `ADB-XXX-XXXXX`. This App ID is what the AEP Mobile SDK uses at runtime to fetch your property's configuration, extensions, and rules from Adobe's CDN; without the correct App ID, the SDK silently does nothing. Next, note your report suite ID (example: `myapp.prod`). Your admin can find this in Adobe Analytics under Admin → Report Suites. The report suite ID is required both for SDK configuration and for Analytics 2.0 API calls. Write down: (1) your App ID, (2) your report suite ID, and (3) your Adobe Organization ID (visible in the Adobe Admin Console, format: `XXXXXXXXXXXXXXXXXXXXXXXXX@AdobeOrg`). You will need all three in later steps. If you do not have access to Adobe Data Collection, stop here and request provisioning from your Adobe administrator — you cannot proceed without these identifiers.

In FlutterFlow, navigate to the left nav → Custom Code → + Add → Action. Name it `initAdobeAnalytics`. In the Dependencies field, you will need to add the Adobe Experience Platform pub.dev packages. Because Adobe does not publish an official flutter package to pub.dev, the standard approach is to use a Dart FFI / method-channel wrapper that bridges to the native AEPCore and AEPAnalytics SDKs. Search pub.dev for community wrappers (search `adobe_analytics_flutter` or `aep_flutter`) and note the exact package name and version. Add the package in the Dependencies field of your Custom Action, using the format `package_name: ^x.y.z`. In the Dart code body, write the initialization logic. You must guard web with `kIsWeb` because the native SDK cannot run in a browser context. Call `MobileCore.setApplication()` if required by the native wrapper, then `MobileCore.configureWithAppId('YOUR_APP_ID')` to fetch the property configuration, followed by `Analytics.registerExtension()` (or the equivalent call in the wrapper you chose). Set your lifecycle callbacks so the SDK tracks app foreground/background transitions automatically, which is required for session tracking in Adobe Analytics. Once the Custom Action is saved, go to your app's root widget or first page → Actions panel → + Add Action → set it to run on Page Load → select your `initAdobeAnalytics` Custom Action. This ensures the SDK initializes once at startup before any screen-view or event calls fire. Remember: this Custom Action will not execute in FlutterFlow web Test Mode or the preview canvas — you must test it in Run Mode on a connected device or in a downloaded APK/IPA build.

1// custom_action.dart — initAdobeAnalytics
2// Replace 'your_app_id' with the App ID from Adobe Data Collection
3import 'package:flutter/foundation.dart';
4// Import your chosen AEP Flutter wrapper package here
5// e.g. import 'package:adobe_experience_platform/adobe_experience_platform.dart';
6
7Future<void> initAdobeAnalytics() async {
8  if (kIsWeb) {
9    // AEP Mobile SDK does not support web — skip silently
10    return;
11  }
12  try {
13    // Configure with your mobile property App ID
14    await MobileCore.configureWithAppId('YOUR_APP_ID_FROM_DATA_COLLECTION');
15
16    // Register the Analytics extension before calling start
17    await Analytics.registerExtension();
18
19    // Start the SDK lifecycle
20    await MobileCore.start(() {
21      MobileCore.lifecycleStart({});
22    });
23  } catch (e) {
24    // Log initialization failure without crashing the app
25    debugPrint('Adobe Analytics init error: $e');
26  }
27}

With the SDK initialized, you now need to fire tracking calls at the right moments. Create two more Custom Actions: `trackAdobeState` (for screen views) and `trackAdobeAction` (for user events like button taps, purchases, and sign-ins). Each Custom Action accepts string arguments — for `trackAdobeState` that is `stateName` (the screen name) and an optional map of context data; for `trackAdobeAction` it is `actionName` and context data. In the Dart code for `trackAdobeState`, call `Analytics.trackState(stateName, data: contextData)` using your AEP wrapper. Adobe Analytics maps `trackState` to page view hits in the report suite, so use descriptive names like `'home_screen'`, `'product_detail'`, or `'checkout_step_2'`. For `trackAdobeAction`, call `Analytics.trackAction(actionName, data: contextData)` — these appear as custom events in the report suite. Once the Custom Actions are saved, wire them in the Action Flow Editor. For each page in your FlutterFlow app, click the page widget → Actions → + Add Action → On Page Load → select `trackAdobeState` → set the `stateName` argument to a hardcoded string like `'home'`. For buttons like 'Add to Cart' or 'Complete Purchase', add a chain: the primary action (e.g., a Firestore write) followed by `trackAdobeAction` with the relevant event name. Keep context data payloads lean — include only fields your analytics team actually queries (userId, productId, price, categoryName) to avoid bloating the hit with unnecessary custom variables. Remember that Custom Actions do not execute in the FlutterFlow preview canvas. During development you will need to use Run Mode on a physical device and check the Adobe Analytics real-time report or the Data Collection Validation tool (Griffon/Assurance) to confirm hits are arriving.

1// trackAdobeState Custom Action
2import 'package:flutter/foundation.dart';
3
4Future<void> trackAdobeState(
5  String stateName,
6  Map<String, String>? contextData,
7) async {
8  if (kIsWeb) return;
9  try {
10    await Analytics.trackState(
11      stateName,
12      data: contextData ?? {},
13    );
14  } catch (e) {
15    debugPrint('trackState error: $e');
16  }
17}
18
19// trackAdobeAction Custom Action
20Future<void> trackAdobeAction(
21  String actionName,
22  Map<String, String>? contextData,
23) async {
24  if (kIsWeb) return;
25  try {
26    await Analytics.trackAction(
27      actionName,
28      data: contextData ?? {},
29    );
30  } catch (e) {
31    debugPrint('trackAction error: $e');
32  }
33}

If your use case requires reading report data back into the FlutterFlow app — for example, to show a founder-facing conversion dashboard or surface segment data to editors — you must call the Analytics 2.0 API. This API authenticates with an OAuth Server-to-Server credential (the current Adobe standard, replacing the older JWT service-account flow) created in the Adobe Developer Console at developer.adobe.com → Projects → New Project → Add API → Adobe Analytics → Server-to-Server (OAuth). Once provisioned, the Developer Console gives you a Client ID and a Client Secret. These credentials grant access to your entire Adobe Analytics organization — they cannot under any circumstances be placed in a FlutterFlow API Call header or a Dart Custom Action, because they would ship inside the compiled app bundle. Anyone who decompiles the IPA or APK can extract them. The solution is a lightweight proxy: a Firebase Cloud Function (Node.js) or Supabase Edge Function (Deno) that holds the Client ID and Client Secret as environment variables, exchanges them for a short-lived access token by calling `https://ims-na1.adobelogin.com/ims/token/v3`, then forwards the reporting request to `https://analytics.adobe.io/api/{companyId}/reports` with the `Authorization: Bearer {access_token}` and `x-api-key: {client_id}` headers. The function accepts a JSON body from FlutterFlow specifying the report suite ID and the report definition (date range, metrics, dimensions), calls Adobe, and returns only the data fields your app needs. Cache the access token in the function's memory — it is valid for 24 hours; exchanging for a new token on every request is wasteful and may hit Adobe's IMS rate limits. Deploy the function and note its HTTPS endpoint URL. This is the only URL that will go into FlutterFlow.

1// Firebase Cloud Function proxy — index.js
2const functions = require('firebase-functions');
3const axios = require('axios');
4
5const CLIENT_ID = process.env.ADOBE_CLIENT_ID;
6const CLIENT_SECRET = process.env.ADOBE_CLIENT_SECRET;
7const COMPANY_ID = process.env.ADOBE_COMPANY_ID;
8const REPORT_SUITE_ID = process.env.ADOBE_REPORT_SUITE_ID;
9
10let cachedToken = null;
11let tokenExpiresAt = 0;
12
13async function getAccessToken() {
14  if (cachedToken && Date.now() < tokenExpiresAt) return cachedToken;
15  const res = await axios.post(
16    'https://ims-na1.adobelogin.com/ims/token/v3',
17    new URLSearchParams({
18      grant_type: 'client_credentials',
19      client_id: CLIENT_ID,
20      client_secret: CLIENT_SECRET,
21      scope: 'openid,AdobeID,read_organizations,additional_info.roles,additional_info.projectedProductContext'
22    }),
23    { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
24  );
25  cachedToken = res.data.access_token;
26  tokenExpiresAt = Date.now() + (res.data.expires_in - 60) * 1000;
27  return cachedToken;
28}
29
30exports.adobeAnalyticsProxy = functions.https.onRequest(async (req, res) => {
31  res.set('Access-Control-Allow-Origin', '*');
32  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
33  try {
34    const token = await getAccessToken();
35    const reportRes = await axios.post(
36      `https://analytics.adobe.io/api/${COMPANY_ID}/reports`,
37      req.body,
38      {
39        headers: {
40          'Authorization': `Bearer ${token}`,
41          'x-api-key': CLIENT_ID,
42          'x-proxy-company-id': COMPANY_ID,
43          'Content-Type': 'application/json'
44        }
45      }
46    );
47    res.json(reportRes.data);
48  } catch (e) {
49    res.status(500).json({ error: e.message });
50  }
51});

With the proxy deployed and verified, add it to FlutterFlow as an API Group. In the left nav, click API Calls → + Add → Create API Group. Name it `AdobeAnalyticsProxy`. Set the base URL to your Firebase Cloud Function or Supabase Edge Function HTTPS endpoint (for example, `https://us-central1-your-project.cloudfunctions.net/adobeAnalyticsProxy`). You do not need any shared authentication headers in the API Group because the proxy handles Adobe auth internally — leave the Headers section empty. Now add an API Call inside the group: click + Add Call, name it `GetConversionReport`, set the method to POST. The request body should be a JSON object that tells Adobe which metrics and dimensions to return. Because you are posting to your proxy, you control this shape — keep it simple, for example `{ "rsid": "myapp.prod", "globalFilters": [...], "metricContainer": { "metrics": [...] } }`. Add FlutterFlow Variables for the date range start and end (`startDate`, `endDate`) and substitute them into the body using the `{{ variable }}` syntax. After saving the call, click Response & Test → paste a sample JSON response from a real Adobe report call (or copy from your Postman test) → click Generate JSON Paths. FlutterFlow will parse the nested structure and generate paths like `$.rows[*].data[0]` for metric values and `$.rows[*].itemId` for dimension items. Create a custom Data Type (left nav → Data Types → + Add) with fields matching the fields you care about — for example `ConversionMetric` with `date: String`, `conversions: Double`, `revenue: Double`. Map the JSON Paths to these fields. In the UI, bind a List widget to the API Call (set it as a backend query) and map each `ConversionMetric` field to a stat card or chart widget. Gate the entire dashboard screen behind your app's authentication so only authorized users can see the revenue data. If the report response is large (many rows), add pagination parameters to the API Call body.

1// Example API Call body (POST to proxy)
2{
3  "rsid": "{{ reportSuiteId }}",
4  "globalFilters": [
5    {
6      "type": "dateRange",
7      "dateRange": "{{ startDate }}/{{ endDate }}"
8    }
9  ],
10  "metricContainer": {
11    "metrics": [
12      { "columnId": "0", "id": "metrics/orders" },
13      { "columnId": "1", "id": "metrics/revenue" }
14    ]
15  },
16  "dimension": "variables/daterangeday",
17  "settings": {
18    "limit": 30,
19    "page": 0
20  }
21}

Before shipping to production, address iOS 14.5+ App Tracking Transparency (ATT) requirements. If you are using Adobe Analytics for cross-app attribution or identity stitching (linking your app's users to users identified in other apps or web properties via Adobe's ECID/MCID), iOS requires you to request ATT permission before any cross-app tracking occurs. FlutterFlow's Permissions settings (Settings & Integrations → App Settings → Permissions) let you enable the Tracking permission, which adds the required `NSUserTrackingUsageDescription` to your iOS Info.plist. For product analytics strictly within your own app (no cross-app attribution), ATT is generally not required, but you should still implement a GDPR/CCPA consent gate if your users are in the EU or California. The AEP Edge Consent extension handles this if you are on the Edge Network path — it gates all data collection until the user grants consent. For a simpler approach, store a `analyticsConsentGranted` boolean in FlutterFlow App State, check it in your `initAdobeAnalytics` Custom Action before calling `MobileCore.configureWithAppId`, and present a consent dialog on first launch using a Conditional widget. For the final end-to-end test, download a debug build of your FlutterFlow app to a real iOS and Android device. Use Adobe Experience Platform Assurance (connect via QR code from the Assurance UI at experience.adobe.com) to watch SDK events in real time as you navigate the app. Confirm that: (1) `trackState` fires with the correct screen names on navigation, (2) `trackAction` fires on key user events with the right context data, (3) the proxy API call returns correct report data, and (4) no secrets appear in the network traffic from the device. Once verified, publish your FlutterFlow app and monitor the report suite for incoming data over 24-48 hours to confirm production stability. If you need help setting up the native SDK method channels or deploying the JWT proxy for an enterprise Adobe Analytics account, RapidDev's team builds FlutterFlow integrations like this every week — free scoping call at rapidevelopers.com/contact.