Thanks for choosing devtodev analytics!

devtodev provides SDKs that give you the ability to measure user behavior and player journeys using basic and custom events.

We have SDKs for the most popular OS and engines:

Version 2.2 (28 Mar 2025)

Added A/B test functionality (Beta).

Version 2.1 (06 Dec 2024)

, which carry information about the user's personal data, are excluded from the SDK.

1. Visit our website www.devtodev.com and click Get started.

1. Fill out the registration form.

1. You will receive an email to confirm your registration.

Custom event descriptions in Funnels

Released: 28/11/2025

Quickly find out the meaning behind an event. In Conversion funnels report, hover over an event or a parameter, and a description will appear. If you do not have any event descriptions yet, you can add them manually or generate them using AI in Tuning -> Custom event configurations.

Space is an information field where you will work. Later on, you will add your application to the space.

1. Click Create Space.

1. To create a space, you need to fill in:

Here are some simple steps to start using our service:

Available platforms

Set up push campaigns in devtodev

Add Application

Once you've created the space, you'll see the Add Application button in the devtodev interface. Click on it to add an application to the space.

1. First, you need to select a platform.

Test devices

Add a device to test your integration:

Apps targeted at children

When developing and publishing apps targeted at children under 13 years old, you need to ensure special conditions for data processing.

Check out how to enable compliance mode for , , and .

How to check event logs in devtodev interface

You can check the incoming events in the User card () or in the (Settings -> SDK -> Integration -> Event Log).

To check events faster, mark the User card as a Tester. This way the log in the User card will not be cached and the events will appear much quicker.

Configure Revenue rates and transaction checks

You can change the default revenue rates for your project in Settings -> SDK -> .

If necessary, you can also disable some of the and set up transaction value limits.

How to enable SDK debug logs

Change LogLevel value to DTDLogLevel.Debug in the Initialization configuration.

Check out examples for different platforms in the section.

Data collected by devtodev automatically

Some of the events and properties are sent to devtodev automatically by the SDK.

Information about a device/user:

• Event timestamp

• Timezone

• Tracking status (iOS, Android) – the state of the flag for permission of ad tracking.

• App version (must be specified by developer for WEB projects).

Automatically sent events:

• Session start – beginning of application activity with the date.

• Activity period – duration of application activity.

• The source of app install (only from Google Play), sent once.

Data received by the server from queries’ metadata

• Install date – date of the first launch of an application with integrated devtodev SDK.

• Last seen date – date of the last incoming query.

• IP-address – anonymized IP-address.

• Country – defined by IP.

Integration

Please do the following to integrate your web application with devtodev:

1. to the Space using the wizard for adding applications.

2. To integrate SDK, add the following line to the tag of your page:

1. Initialize the SDK.

Initialization

In order for SDK for WEB to start working, it is necessary to perform initialization right after the page is loaded and you have a basic user identifier at your disposal.

• You can find the App ID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).

• config – is an object that is used for specifying additional properties during initialization.

Config

Example:

How devtodev SDK tracks sessions

Session measurement is an important metric for product analysis as it allows us to determine how frequently and for how long users interact with our website or application. However, it is important to note that session tracking methods on mobile and web applications have their own peculiarities.

When a user starts a session in the application, the SDK recognizes that the application is active, indicating that it has gained focus (when the app is brought into the foreground). If the last recorded activity was more than 10 minutes ago, a Session Start event is sent.

Application activity refers to the period of time when the application is in focus, meaning the application or web page is open and the device screen is active. The focus is lost if the application goes into the background or if another website is opened in the current tab.

We measure the duration of application activity using a technical event called User Engagement (UE). It starts counting the time as soon as the application receives focus and sends the activity counter data to the server.

If, for any reason, the information about the duration of the activity could not be sent, it will be sent the next time the application is initialized and has internet access. However, the activity will only be included in devtodev reports if it has been less than 7 days since the session, as events from a previous period more than 7 days ago are ignored.

Thus, we have information about "Session start" and the duration of activity, but there is no specific "Session end" event.

All events performed by the user are marked with the session start date on which they occurred (sessionid field in SQL tables).

Platform specifics

Mobile applications

It is difficult to determine the beginning and end of a session because users often switch between screens of different applications. If an application on a mobile device receives focus and the last active time (in focus) was more than 10 minutes ago, a new session will start and a Session Start event will be sent to devtodev.

For example, the user opens the application, spends a minute in it, and then puts the application in the background, a Session Start event will be sent to devtodev in the first second. After a minute, when the application goes into the background or is closed, an event with information about the duration of activity (UE) will be sent to the server as the focus is lost.

Web projects

It is not possible to detect when the user closes the page. Therefore, the UE event (duration of activity) is sent to the server every 2 minutes. To minimize the loss of information about the session duration to no more than two minutes in case of session termination, the SDK additionally saves the duration every 5 seconds and will send the information about the last duration upon the next activity. If there is no next session, the information about the last two minutes may be lost.

Let's consider an example where a user opens a webpage, spends 1.5 minutes on it, then opens another page on the site and spends another 1.5 minutes there.

A Session Start event will be sent in the first second, and every 5 seconds, information about the activity will be saved. After 2 minutes from the start of the session, a UE event with 2 minutes of activity will be sent to the server, and after the third minute, the activity of 1 minute will be recorded in the Local Storage. Information about this activity will be sent during the next user session.

Windows

The SDK cannot control app activity for Windows Standalone projects hence this responsibility is passed on to the developer. During the SDK initialization, the activity is triggered automatically, and later the activity status will not change automatically.

For tracking app activity, the developer can use the DTDAnalytics.StartActivity and DTDAnalytics.StopActivity methods.

It is recommended that you use the DTDAnalytics.StopActivity method to stop the activity when the app goes into the background or being closed. If the window is re-opened from the taskbar it is recommended to renew the activity by using the DTDAnalytics.StartActivity method.

Session metrics in reports

In , Engagement -> , and , we encounter the following metrics:

• Session duration – average session time of one user. Calculated as (Total Sessions Length / Number of sessions) averaged by users.

• Number of sessions – average number of sessions per user. Calculated as the Number of sessions divided by the Number of users.

• Total daily time spent – average total time per day spent in the user application. Calculated as Total Sessions Length divided by the number of Active Users.

Session metrics in SQL

SQL Wizard

In the SQL wizard, there is a parameter called session.Duration, which is tracked by the UE event. The session.Duration parameter represents the duration of the activity, i.e., the time the application is in focus, and it is not equal to the session duration.

sessions.Count is the number of Session Start events received from the user.

SQL Editor

The table has two types of eventtype field in SQL:

• ss: represents the Session Start event received from the user.

• ue: represents User Engagement – the time that the application was in focus (active), providing information about time parameters and activity duration.

From this data, you can calculate the average session length by dividing the sum of activity lengths from all rows for the desired period by the sum of all session starts for the same period. We recommend using extended time periods to obtain a more reliable result.

Use AI assistance to speed up the integration process.

If you have any questions regarding the integration, let us know by using the form or reach out to our Customer Success team directly within the platform. We will also greatly appreciate your feedback. Please add AI INTEGRATION when submitting your request.

Preparation and prompt

Get Unity Integration Guide File

and add it to your Unity project folder. We recommend creating a folder called docs and placing the guide inside it. This ensures the AI coding agent can easily access and use it during analysis.

Open your AI-agent, and select your Unity project folder. The agent will begin indexing all project files, including the markdown guide. Wait a few moments until indexing is complete.

Create prompt

Create a clear and effective prompt for the AI-agent. The prompt should:

• Assign the AI a role (like "You are a product engineer").

• Specify your goal: integrate DevToDev events properly.

• Reference the guide using @devtodev_unity_integration_guide.md.

Copy and paste the promt text into the AI-agent chat window.

.

Add references to integration guide

Attach the guide file inside the prompt. You can do this in two ways:

1. Find all the guide mentions in the prompt and delete that placeholder text. Then, drag the file from the docs folder into the chat window. The AI-agent will automatically recognize and link the file.

2. Alternatively, type @ and start typing "devtodev" — the agent will suggest the guide file. Usually it is at the top of the list.

Now click Send and let the AI coding agent generate the integration.

It will:

• Analyze your codebase

• Understand game logic

• Suggest where and how to insert DevToDev analytics events.

Events generation

Check and review the list of events generated by the AI-agent. You can edit the list by removing the unnecessary or duplicate events. You can also ask the AI to revise its suggestions.

After you have finished reviewing and modifying the suggested events file, you can proceed to the next step of integration. The AI-agent may then generate a new class — usually something like AnalyticsManager — to send events to Devtodev.

Further integration

The coding agent might show some errors if Unity has not recompiled yet. Switch to the Unity Editor and wait for it to finish compiling. Once done, the errors in AI-agent will disappear.

After generating the integration, the AI-agent will also produce a documentation file (like ANALYTICS_SETUP.md).

It describes:

• Where events were added

• How to use the generated AnalyticsManager class

• What next steps are required to finish setup.

Follow that instruction carefully to complete your devtodev analytics integration properly.

Here you'll find the principles of processing data about real payments, tips for the integration of the Payment event and anti-cheat methods used in devtodev.

Payment event integration

Gross metrics are one of the key indicators of the app’s performance. Therefore, it is important to approach the integration of the very seriously.

There are four parameters that are sent in the Payment event:

Autocapture is a set of features in devtodev that allows you to collect data automatically, without manually sending events from the client side. It is designed to simplify integration, reduce engineering effort, and ensure data consistency across platforms.

Currently, Autocapture supports purchase tracking, refund tracking, and AI-assisted integration. Web auto-tracking is in development.

How it works

Each Autocapture feature collects data from validated sources such as the App Store, Google Play, or SDK behavior. In most cases, you only need to enable the feature in the devtodev settings and initialize the SDK accordingly. No additional coding is required.

In devtodev you can mark a device as a test device. You can do so in the section or in Settings -> SDK -> .

The system will exclude from the reports all incoming events from the test devices (except Real-time dashboard). You can check the evets in Settings -> SDK -> Integration -> or in the Users & Segments section.

When you mark the User card as a Tester, the log in the User card will not be cached and the events will appear much quicker.

If the app is in test mode, all devices with this app are added automatically to the list of test devices (up to 100 users). You can switch to Production mode manually in Settings -> .

Users & Segments

Export via API

Use devtodev API to export raw data.

Below you can find APIs for 3rd party services. You can use them in case devtodev does not provide an integration to a specific 3rd party service.

Check the list of available Ad Revenue services.

Check the list of available Attribution trackers.

You can find full description of devtodev events in this article:

Where to start

Tutorial is a very important part of any project because the first session lays the foundation for future retention and monetization indicators.

devtodev allows to analyze how users complete the tutorial, find bottlenecks, and measure the time it takes for users to complete the tutorial. These questions can be answered with the help of the Tutorial analysis report.

If users in your project become more experienced and raise their level

Many game projects have levels, which means that as users become more experienced, they gradually increase their level. In this case levels have a linear structure: the level N is followed by the level N+1.

When players move to the next level, you need to use the . Reports such as Economy balance and Player levels are built by levels and are based on this event.

Also, if your project has in-game currency, you can send information about the current amount of in-game currency players have using the LevelUp event. This data allows to evaluate the average amount of in-game currency that players have on a particular level.

For example, this is the . It shows how users are distributed among levels, the percentage of users who remain on a particular level, the revenue of a particular level, etc.

If it is possible to pass / fail a level in your game

There are many projects (for example, Match-3 games), where players attempt to pass a level. Their attempts may be either successful or unsuccessful. In addition, during a certain attempt some numerical indicators can change: the number of stars, resources, in-game currency.

To analyze these attempts, we've created a basic . With Progression event you can send information about how players pass a particular game location, whether their attempt was successful, and how numerical indicators change.

Based on the Progression event, we build the , where all indicators are calculated by game locations, for successful and unsuccessful attempts.

If there is a virtual currency in your project

Many games, especially f2p, have in-game currency. Players can accumulate currency, or buy it for real money. They can then spend it on virtual goods. To work with virtual currency, devtodev has developed the following events:

• – to send information about purchases made by players. Please note that these are only purchases made with virtual currency, while information about purchases for real money is sent with the .

• – to show information about movements of virtual currency. For example, if a player earns currency or receives it for some actions, you can use Currency Accrual to see this information.

All the game economy reports are based on these events.

With the help of the Currency Balances by Level tab in the (this one also requires a ), you can see how users spend, earn and accumulate currency on each game level.

The Top Purchases tab in the allows you to analyze the structure of the consumer basket and identify the most popular items among different categories of players.

Custom Events

There may be situations when your project requires events that cannot be tracked by devtodev basic events. Such events can still be sent and analyzed in our system as . It is possible to specify parameter values of custom events.

Here are some examples of user actions that can be sent as custom events: opening an in-game store, clicking on items, buying items. Based on these events, you can then build a funnel and see the conversion on each step.

Some limits for custom events:

1. The number of different event types sent from one project should not exceed 300.

2. The event name must not exceed 72 characters.

3. One event can contain up to 20 parameters, each of them with unique names of up to 32 symbols.

4. Parameters can be string or numeric:

Here is some expert advice to avoid problems with limits on custom events:

• There is no need to send user IDs in parameters (they are collected by default).

• Do not send time in the timestamp format (it is also collected by default).

If you want to check transactions for validity

To exclude from statistics transactions made by cheaters, you can use devtodev . By using this method, you will be able to check payments for validity before sending them to devtodev.

The verification process is the following:

1. Get response about a completed transaction from the payment system.

2. Either send data about the received transaction for verification by calling devtodev anti-cheat methods or use your own tools for transaction verification.

3. If the transaction has successfully passed verification, perform the Payment event. If the transaction has not passed verification, do not perform the Payment event.

Please do the following to integrate your application with devtodev:

1. Add the application to the Space using the wizard for adding application.

3. Go to your project directory and place the plugin content here: ProjectName/Plugins

4. Restart Unreal Editor and open the plugin menu (Window > Plugins). In the "Analytics" plugin group of your project select DevToDev (and "Blueprint Analytics Framework" in case if you use blueprints). You will be offered to restart Unreal Editor again.

5. Finally, add the following strings into the DefaultEngine.ini configuration file (the file is in "Config" folder of your project):

Project Settings

To get an access to the DevToDev settings, go to Project Settings > DevToDev

Get the keys (they can be found in the application settings: Settings -> SDK -> Integration) and insert the keys in this window. Then choose the Enable Push Notifications option in case if you want to send push notifications through devtodev service.

Initialization

All the events are available in the Analytics block of your Blueprint.

To initialize SDK in a blueprint, first call the "Start Session" event from the Analytics Blueprint Library.

or from the following code

Devtodev allows you to collect refund data automatically for purchases made through the Google Play and App Store platforms. Refunds are recorded as transactions with negative amounts and matched to original purchases whenever possible.

The automatic refund tracking system helps you monitor actual revenue more accurately and analyze refund patterns without manual event configuration.

How it works

Refunds are collected via store APIs or postbacks and processed on the server side. For each refund:

• devtodev attempts to match it to an original transaction by transaction ID.

• The refund is saved as a transaction with a negative amount.

• The event is dated using the refund processing date (not the original payment date).

Setup

To enable refund tracking:

• Set up integration with the App Store or Google Play.

• Go to: Settings → Payments integration → IA refunds tracking.

• Click the ✎ icon next to IA refunds tracking and fill in the fields related to the platform.

• Refund tracking starts working automatically on supported platforms after you enable it in the devtodev interface.

For details on how to set up integration with app stores, see:

Please do the following to integrate your application with devtodev:

1. Add the application to the Space using the wizard for adding application.

2. and add it to 'Linked Frameworks and Libraries' list in the general settings of the project.

3. Add init method into didFinishLaunchingWithOptions method of your AppDelegate.m

   App ID and Secret key can be found in the application settings (Open "Settings" → "SDK" → "Integration").

If the application you integrate SDK in is a part of a cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for a cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

Devtodev allows you to collect payment and subscription information automatically for the Google Play and App Store platforms. All you need to do is enable the corresponding module during the SDK initialization and configure store setting in the devtodev interface.

The automatic payment tracking system will help you avoid integration errors with data submitted using the Real Payment and Subscription events. This system will also help you avoid sending fraudulent transaction data, as each transaction is additionally verified on the Google Play and App Store platforms before being recorded in the database.

2. To start working with the SDK, add the DevToDev.winmd and DevToDev.Background.winmd to the project references.

3. Initialize the library at Application Launching event.

App ID and Secret key can be found in the application settings (Open "Settings" → "SDK" → "Integration").

Example:

If the application you integrate SDK in is a part of cross-platform project, then the user data initialization is required.

Since the analytics of a cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for a cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects you need to set the current player level.

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

devtodev has integration with the following attribution trackers:

• AppsFlyer

• Adjust

• Branch.io

If the tracker you are using is not in the list, you can send data via

Integration

1. Login to your Kochava account and select the application you want to configure.

General Information

In order to work with push notifications, you need to integrate the messaging module. You can do it by using one of the two methods: with the help of the Unity Package Manager (recommended) or by manually importing the unitypackage.

Integration

Official Adjust documentation for enabling devtodev partner module can be found .

1. Go to the

Integration

1. Sign in into Branch.io

2. Go to Data import & Export in the left menu.

Create Alerts in Basic Metrics reports

Released: 21/11/2024

It is now possible to create an alert for a number of metrics straight from the report. Click on the Create alert button in the three dots menu and you will be promted to the Alerts wizard with the preselected metric.

Learn more about the Basic Metrics report

Custom Events: updated Total value overview

Released: 21/11/2024

By default you can see the Total values for selected events above the report. We've added a Show total button so now you can hide this information block. We've also moved all the report customization settings (Metrics settings and Conditional Formatting) to the left for easier navigation.

Widgets: last update time

Released: 21/11/2024

You can now check if the data in the widget is up to date and update it without the need to refresh the whole dashboard. Click on three dots menu and select Refresh data.

Report sharing update

Released: 17/10/2024

We have added a Select All option so you can easily share your report or dashboard with everyone. If you want to share multiple reports, there is now an option to batch select and share them in the Saved reports or Saved Dashboards section.

Dashboard control management update

Released: 13/08/2024

Unified Control for Report Filters and SQL Variables: Before this update you could only add a Period type control for widgets based on non-SQL reports (Basic metrics / Custom Events / Funnel reports). Now it is possible to create and apply common filters such as Country, Language, Channel, Campaign and Paying status.

Simplified default variable value change: You can change the default value directly in the Manage controls panel, without the need to navigate to the original widget.

Add Player Levels report to custom dashboards

Released: 13/08/2024

The Player Levels report has some unique ready-to-use metrics such as Gross revenue and number or players remaining at a specific level. You can now add this report as a widget to a custom dashboard and get the full picture for your game analysis.

Export widgets to CSV

Released: 22/07/2024

Save the report results from the dashboard without opening the original report using Export to CSV. The result will be saved as table. This can be useful for further data processing or sharing the report to colleagues without access to devtodev.

Add Conversion to payments report to custom dashboards

Released: 21/06/2024

You can now save Conversion to N payment, Period until payments, Top converting goods charts to a custom dashboard as widgets. This information will help you analyse the payments in a more convenient way.

Like operator in Custom Events, Funnels and User Flow

Released: 21/06/2024

The Like opertor allows you to create a mask for the string parameter values.

For example, you have a parameter called Item and it has values: offer1, offer2, offer3, offer4. Use the Like operator and type offer, this will select all four of these values in the resulting report.

Add Locations report to custom dashboards

Released: 21/06/2024

The Locations report contains ready-made metrics that allow you to see how users pass the different locations. You can now save this report to a dashboard with other metrics to see the whole picture.

Change metrics' names in Custom events report

Released: 14/05/2024

This update gives you an ability to change the name of any metric in Custom events. You can use more convenient titles and adjust the values with a Round setting. There is also an option to change the Units for a single number widget. The applied metrics' settings will also be saved when you share the report or add it to a dashboard.

Add Cumulative ARPU report to custom dashboards

Released: 14/05/2024

Results from Devtodev’s Cumulative ARPU report can now be saved to a custom dashboard as a widget. This information helps you track crucial Cumulative ARPU metric values for your project.

Acquisition: trafic source filter

Released: 30/04/2024

Previously data from Custom Postback API or SDK Install referrer was not available in the Acquisition section. Now, we have added a Source filter in the Detailed stats report, where you can select the needed trafic sources.

Table widget settings

Released: 30/04/2024

on your dashboard. Improve readability by adjusting the column width automatically (Autofit column width) or by hand. We have also added a Wrap text option for heading and table rows to allow for longer titles.

Extended period of segment expiration

Released: 10/04/2024

With this update, we have extended the expiration date for unused segments to 60 days. If you do not apply the segment to any report, it will expire. However, you will have 30 days to recover this segment before it’s completely deleted.

Axis scale settings

Released: 21/03/2024

Users now are able to customize axis boundaries on their charts to more accurately represent data trends. In cases where the charts are not optimally positioned (or you are not happy with their placement, or want to change the position of the chart), simply clicking on the Axis Scale option allows you to define the minimum and maximum values for the axis.

Managing content created by deleted users

Released: 20/03/2024

When a user deletes their account, or in case the user is removed from the space, their content remains in devtodev. Now, the team can manage the ownership of such content. For example, you can take ownership of the report made by the deleted user, or you can delete it from the space.

Transfer space ownership to another user

Released: 20/03/2024

When the space owner is changing, they need to transfer their ownership. With this update, the owner of the space can select a new owner in User settings and delegate their owner access.

Cohort Timespent in Basic Metrics

Released: 12/03/2024

We’ve added a new metric to our Basic Metrics report – the Cohort Timespent. Previously, you may have known this metric as “Cohort Playtime,” which was created specifically to evaluate user engagement in the Sessions report. And now this metric is also available in Basic Metrics for both game projects and applications.

devtodev SDK for Godot Engine

Released: 27/02/2024

Now you can create games and apps from scratch on all popular engines, including Godot, all while utilizing detailed data analytics tools. Devtodev platform will support you in understanding player behavior, optimization, and increasing user engagement throughout the entire lifetime of the product.

The new Godot SDK is now available for iOS, macOS, and Android platforms, providing you with the tools you need to take your games and apps to the next level.

Copy dynamic segments

Released: 28/01/2024

An existing dynamic segment can be duplicated with just one click. Simply copy the segment and adjust its settings to save time when creating a segment with similar conditions.

More Alert options

Released: 09/01/2024

You can receive notifications if the number of basic or custom events suddenly changes or differs from a specific day. These alerts will inform you about any positive or negative fluctuations.

Also, two new conditions have become available: a comparison with the previous day and a comparison with the same day last week. This allows the alert to activate when yesterday's event count is different from the count on the chosen day.

Manual installation

1. Download the latest version of devtodev SDK from the repository

2. Add DTDAnalytics.xcframework to the project (with Do Not Embed specified)

3. Add frameworks:

• AppTrackingTransparency.framework

• AdSupport.framework

4. Add initialization todidFinishLaunchingWithOptions method:

• An App ID can be found in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).

• config - an object instance of DTDAnalyticsConfiguration, which is used for specifying additional properties during the initialization.

DTDAnalyticsConfiguration

Example:

Integration features

For Objective-C

1. Create Bridging-Header. To do this, you need to add any swift file to the project (don’t delete it later) and choose ‘Create Bridging Header’ in the offered dialog box.

2. Make sure that the ‘Build Settings’ for ‘Defines Module’ value evaluates to ‘YES’.

3. While importing, use: #import <DTDAnalytics/DTDAnalytics-Swift.h>

For SwiftUI

For SDK to function properly, it needs to be integrated at the earliest moment of the app launch. It is recommended that you use the following method of main entry point initialization:

Apps targeted at children

When developing and publishing apps targeted at children under 13 years old, you need to ensure special conditions for data processing. Any mobile app aimed at children or intended for users in a region with strict regulations on child online protection, must comply with current laws.

If your app has to comply with the legal requirements (COPPA), use the following recommendations:

1. Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).

2. To comply with

   1. Remove AppTrackingTransparency.framework and all the links pointing to it.

By connecting Aghanim with devtodev, you can track player-generated events from the Game Hub, ensuring precise tracking of user actions across your entire game environment.

Step 1: Configure the Integration in Aghanim

1. Go to the Aghanim Dashboard → Aghanim Connect → .

2. Click the Install button to enable the integration.

Step 2: Add devtodev attributes to player.verify webhook response

To ensure devtodev correctly identifies users and attributes their actions on the Game Hub, include the devtodev-specific attributes in the webhook response:

The DevtodevDeviceId schema

The device ID object must contain at least one of the following identifiers:

Example webhook response

Once the integration is set up, Aghanim will automatically send events to devtodev, allowing you to track user purchases from the game hub.

Please perform the following actions to integrate your application with devtodev system:

• add the application to the Space using the wizard for adding application

• or install via CocoaPods

• integrate SDK into your application. The integration may be whether partial or including all the possibilities.

CocoaPods

is the easiest way to add devtodev into your iOS project.

1. Firstly, install CocoaPods using

2. Create a file in your Xcode project called Podfile and add the following:

3. Run

   in your Xcode project directory. CocoaPods should download and install the devtodev library, and create a new Xcode workspace. Open this workspace in Xcode.

Manual installation

1. Download the latest version of devtodev SDK from the repository.

2. Include devtodev.framework dependency:

3. Link against the embedded framework:

   Add devtodev.framework to the Linked Frameworks and Libraries section.

We recommend you set the user identifier before SDK initialization, otherwise the user identifier from the previous session will be used since the SDK initialization moment till the setUserID method call.

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

Integration

1. Copy devtodev API key from “3rd Party Attribution. AppsFlyer” panel on " Settings -> 3rd party sources -> Attribution tracking" page in devtodev system. Don't forget to turn on the service.

1. Sign in with .

2. Open the and start manage integration.

1. Select your app, paste the devtodev API key you copied before, select "All media sources, including organic", activate partner and click "Save integration". Integration completed.

For iOS applications we recommend turning off the Advanced Privacy (for iOS 14.5+ and later) option.

Improve matching

CPI data integration

devtodev allows our customers to query CPI data from AppsFlyer via Pull API.

Integration can be enabled by checking the appropriate box. You will need an , which can be found on the Profile -> Security Center -> . For Apple platform App ID is Application ID without the 'id' prefix. For Android platform App ID is Android Package name. Note: App IDs are case sensitive.

Please do the following to integrate your web application with devtodev:

1. Add the application to the Space using the wizard for adding application.

3. To integrate SDK, add the following line to the tag of your page:

Initialization

In order for SDK for WEB to start working, it is necessary to perform initialization right after the page is loaded and you have a basic user identifier at your disposal.

Unique API key can be found in the application settings: "Settings" → "SDK" → "Integration".

Cross-platform application Initialization

In cross-platform applications, the additional user identifier can be used. It is a user cross-platform ID which is unique for all of the platforms. And if a cross-platform ID differs from the ID that is main for the platform, you need to set the cross-platform ID. The cross-platform ID combines the user data for a cross-platform project.

We recommend you apply this method before the SDK initialization, otherwise, the user identifier from the previous session will be used since the SDK initialization moment till the setCrossplatformUserId method call.

If it is difficult to do, set a cross-platform ID as soon as it is available in the application after SDK initialization.

Additional initialization

For the most precise data collection, we strongly recommend specifying some information about the user right after SDK is initiated.

User data initialization

In the first place, this additional initialization is required for gaming applications where the player has a game level as a characteristic.

Application data initialization

It is not obligatory, but if you want to have the ability to build reports with regard to the version of your application, use this method before initialization.

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

General information

To enable Push Notifications you will have to perform the following actions:

• Add the application to your space in devtodev system

• Android. Get API key from Google APIs Console. It is nessesary to activate Google Cloud Messaging for Android before key generation. Detailed information on how to receive an API key you can find in native Android devtodev SDK documentation

• iOS. Generate Developer or Production Certificate for the application and get Private key file (.p12) on its basis. Detailed information on how to receive a Private key file you can find in native iOS devtodev SDK documentation

Project settings

Set Push Notification Enabled in blueprint.

Creating a new push notification in devtodev interface

1. Open PUSH NOTIFICATIONS section and click on "Add new campaign" button

2. Fill in campaign name, select an app for delivery*

3. Choose user group to send a message. You can choose existing segment or create a new one

4. Enter notification details

Push Notifications (UWP)

The DevToDev.Messaging package necessary for notifications is available in the NuGet package manager.

SDK is available as a library in AAR (recommended) and JAR. The library is available in Maven Central repository and on repository.

Step 1. If you use Gradle for the applications build, add mavenCentral() into gradle.build file of your application and specify the following relationship in dependencies block:

In case you don't use Gradle, you can and add the library into the project.

Step 2. Initialize the library in the first Activity method onCreate() in the following way:

App ID and Secret key can be found in the application settings: "Settings" → "SDK" → "Integration".

Godot SDK integration

The DevToDev SDK extends the Godot engine in a modular way and supports the following platforms: MacOS, iOS, Android.

Requirements

• Godot engine 4.0+ ()

• .

• build system.

• SDK module source code ()

The SDK module installation

The SDK module is available in . Download the Source code of latest release and copy d2d_analytics folder to the modules(/godot/modules/) folder of Godot engine source code.

To work in the Godot editor, compile the engine source code and the analytics module:

SDK Initialization

For initialization, add the following code at the start of your application:

You can find the AppID in the settings of the respective app in devtodev (Settings → SDK → Integration → ).

config – an object instance of GDDTDAnalyticsConfiguration, which is used for specifying additional properties during the initialization

Example:

Project export

Export for MacOS

Open the Export Template Manager to download and install templates:

Open a terminal, go to the root directory of the engine source code. Compile a custom template for MacOS (see for MacOS), select Debug or Release build and processor architecture. To support both architectures in a single Universal 2 binary, use lipo:

The next step is to prepare a custom template as a macos.zip archive. Don't forget to add the DTDAnalytics native library, copy libDTDAnalytics.dylib to macos_template.app/Contents/MacOS/.

Open the Export menu and specify the path to the prepared custom template:

Export for iOS

Open the Export Template Manager to download and install templates:

Open a terminal, go to the root directory of the engine source code. And compile a custom template for iOS (see for iOS). To work with the iOS simulator, compile the sources with the ios_simulator=yes flag. To support both architectures in a single Universal 2 binary, use lipo:

The next step is to prepare a custom template as an ios.zip archive. Don't forget to add the DTDAnalytics native library, copy DTDAnalytics.xcframework to ios_xcode/.

In XCode project:

1. Add DTDAnalytics.xcframework to the project (with Do Not Embed specified)
2. Create Bridging-Header. To do this, add any swift file to the project (don't delete it later) and select 'Create Bridging Header' in the dialogue box that appears.
3. Add frameworks:

Export for Android

Click to install android templates:

After installing the template, an android folder will appear in your project.

Move the d2d_analytics/native/androidAnalytics.aar to the android/plugins/ folder in your project. You will also need to create an Analytics.gdap file in android/plugins/ with the following content:

Next, Analytics should appear in the Plugins section, check it out:

The next step is to compile the Godot engine for Android (see ), choose debug or release build, and select the processor architecture.

After successful compilation execute the following commands:

In the next step in godot-4.0-stable/bin you will see godot-lib.template_debug.aar or

godot-lib.template_relaese.aar.

You need to copy and replace this file to the previously installed template in your project at the path:

• appName/android/build/libs/debug - for debugging

• appName/android/build/libs/release - for release

After these steps, you are ready to export your Android app.

Make sure that Use Gradle Build (in the Gradle Build section), Analytics (in the Plugins section) and the previously compiled Architecture (in the Architectures section) are selected.

Please do the following to integrate your application with devtodev:

1. Add the application to the Space using the wizard for adding application. Attention! If your Adobe Air can be used for compilations for different platforms, you need to add the applications in devtodev for each platform. As a result, the statistics will be gained for each platform separately.

3. Add com.devtodev.sdk.ane library to your application

4. For Android add the following permissions to the MyApplication.xml file:

To automatically gather the referrals data on Android, add the following strings into tag

For other platforms no changes are needed.

5. Add the following imports to your source

6. Add following source into initialize event in MyApplication.mxml file:

The appKey and appSecret values are unique for each app on each platform and can be found in the settings of appropriate app ("Settings" → "SDK" → "Integration").

For example: file MyApplication.mxml:

file MyApplication.xml:

Additional initialization

If the application you integrate SDK in is a part of cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

Add Retention report to custom dashboards

Released: 20/12/2023

Results from Devtodev’s Retention report can now be added to a custom dashboard as a widget. This information helps you track crucial retention metric values for your project. The update eliminates the need for SQL in building the report and adding it to the dashboard.

Here are some examples of how you can use this functionality:

To begin working with analytics, you need to start sending events (information about user activity in the project) to the analytics system.

devtodev provides basic events that drive the majority of the reports.

Sessions

Users start with opening the app, and this process we call "starting a session". For your convenience, in the majority of devtodev SDKs this event is integrated automatically.

We use two events that we can use to examine the duration of the sessions. The first event captures the start date of a new session and the second captures the duration of each application activity (time when application is in focus). In our experience, this is the most reliable solution at the moment.

At the moment when application receives focus (this may be the moment the SDK is initialized / the application is opened / the device wakes up from the sleep mode with the focus on the application), we begin to assume that the application becomes active and begin to count the duration of the activity.

If the application loses focus (minimizing the application / device is going into the sleep mode / switching to another application / exiting the application), we consider that the activity is completed and we send its duration to the devtodev server. This is an application activity event.

We consider the start of a new session to be the moment when the application receives focus (see the description above), but at the same time we take into account that more than 10 minutes have passed since the last activity of the application. Otherwise, we count that the previously launched session continues. More detailed information on tracking sessions can be found on the page.

Reports based on a Session event :

Real Payment

If users can use real money to make purchases in your project, you need to integrate the Payment event. When devtodev receives data about sessions and payments in your app, we can calculate all financial metrics (gross, revenue, average check) and metrics of the project’s financial efficiency (ARPU, ARPPU, paying share, LTV).

Reports based on a Payment event :

Subscriptions

If your application has subscriptions, you can integrate this event to analyze the financial data as well as the structure of your subscribers. Devtodev integrations allow you to receive information about subscription purchases even if the user doesn’t open the app (auto-renewable subscriptions).

Reports based on Subscription events:

Onboarding (tutorial)