> ## Documentation Index
> Fetch the complete documentation index at: https://docs.y.uno/llms.txt
> Use this file to discover all available pages before exploring further.

# Signifyd Antifraud (Android)

> Add Signifyd device profiling to Yuno Android checkouts with the yuno-sdk-antifraud-signifyd module.

The `yuno-sdk-antifraud-signifyd` module adds **Signifyd device profiling** to the Yuno Android SDK. When Signifyd is a fraud screening provider in your Yuno payment route, the Yuno SDK profiles the device during checkout with Signifyd's Android SDK and sends the session ID with the payment, for any payment method. Yuno then forwards it to Signifyd with the order.

> [!NOTE]
>
> The module is **opt-in**: add it only if your Yuno account uses Signifyd for fraud screening. Installing it does not change your payment or enrollment code.

Unlike the other modules, Signifyd's Android SDK is not on Maven Central or in Yuno's repository: it is only available from **Signifyd's private registry**, and your build downloads it with **your own Signifyd token**. Yuno does not bundle or redistribute Signifyd's SDK. Activation follows the same rules as every other module, see [External Native Modules (Android)](https://docs.y.uno/docs/sdks/external-native-modules/android-overview.md).

## Requirements

* Android **6.0 (API 23)** or higher.
* **android-sdk 2.29.0 or higher** (`com.yuno.payments:android-sdk`).
* `kotlin-stdlib` **1.9.22** or higher, required by Signifyd's SDK.
* A **Signifyd SDK download token**, issued by your Signifyd solution engineer.
* Signifyd enabled as a **fraud screening provider** in your Yuno payment route.

## Installation

**1. Store your Signifyd token**

The token lets Gradle download Signifyd's Android SDK (`com.signifyd:profiling:5.1.4`) from Signifyd's private registry. It is only used when your build resolves dependencies, never at runtime: if it expires, new builds fail and apps you already released keep working.

* **Your machine:** add it to the `gradle.properties` file in your Gradle user home (`~/.gradle/gradle.properties`), not to your project:

  ```properties theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
  signifydGithubToken=<your-signifyd-token>
  ```

* **CI:** expose it from your secret store as the environment variable `ORG_GRADLE_PROJECT_signifydGithubToken`.

Never commit the token to your repository.

**2. Declare Signifyd's registry**

In your `settings.gradle` (or `settings.gradle.kts`), add Signifyd's registry inside `dependencyResolutionManagement`, next to the repositories you already declare:

> [tab] Groovy DSL
>
> ```groovy theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencyResolutionManagement {
>     repositories {
>         exclusiveContent {
>             forRepository {
>                 maven {
>                     url "https://maven.pkg.github.com/Signifyd-sdks/android-sdk-dist"
>                     credentials {
>                         username = ""
>                         password = providers.gradleProperty("signifydGithubToken").orNull
>                     }
>                 }
>             }
>             filter { includeGroup "com.signifyd" }
>         }
>     }
> }
> ```

> [tab] Kotlin DSL
>
> ```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencyResolutionManagement {
>     repositories {
>         exclusiveContent {
>             forRepository {
>                 maven {
>                     url = uri("https://maven.pkg.github.com/Signifyd-sdks/android-sdk-dist")
>                     credentials {
>                         username = ""
>                         password = providers.gradleProperty("signifydGithubToken").orNull
>                     }
>                 }
>             }
>             filter { includeGroup("com.signifyd") }
>         }
>     }
> }
> ```

`exclusiveContent` makes Gradle look for `com.signifyd` artifacts only in that registry and sends your token only there.

**3. Add the module**

Add the module to your app module's build file, next to the Yuno SDK dependency:

> [tab] Groovy DSL
>
> In `build.gradle`:
>
> ```groovy theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencies {
>     implementation "com.yuno.payments:android-sdk:2.29.0"
>     implementation "com.yuno.payments:yuno-sdk-antifraud-signifyd:1.0.0"
> }
> ```

> [tab] Kotlin DSL
>
> In `build.gradle.kts`:
>
> ```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencies {
>     implementation("com.yuno.payments:android-sdk:2.29.0")
>     implementation("com.yuno.payments:yuno-sdk-antifraud-signifyd:1.0.0")
> }
> ```

The module already brings Signifyd's SDK, so you do not add `com.signifyd:profiling` yourself.

**4. Enable Signifyd in Yuno**

Ask your Yuno account team to add Signifyd as a fraud screening provider in your payment route. Without it, the module is installed but the Yuno SDK never runs it.

## Activating the module

The module **registers itself** when your app process starts, through [Jetpack App Startup](https://developer.android.com/topic/libraries/app-startup). No code is required beyond adding the dependency, and you do not set any Signifyd key in your app: the Yuno SDK uses the Signifyd SDK key that Yuno serves for your account during checkout.

To confirm the module loaded, filter Logcat by its tag right after the app starts and look for the `registered` line:

```bash theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
adb logcat -s SignifydAntifraud
```

> [!TIP]
>
> Once the module is installed and Signifyd is in your payment route, the Yuno SDK uses it automatically in every checkout. You do not need to change any payment or enrollment code.

> [accordion] If your app disables App Startup
>
> If your app removes the App Startup content provider from its manifest (`androidx.startup.InitializationProvider` with `tools:node="remove"`), the module cannot register on its own. Run its initializer yourself, once, before `Yuno.initialize(...)`:
>
> ```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> import androidx.startup.AppInitializer
> import com.yuno.antifraud.signifyd.SignifydAntifraudInitializer
>
> AppInitializer.getInstance(applicationContext)
>     .initializeComponent(SignifydAntifraudInitializer::class.java)
> ```

## How it works

1. When the app starts, the module registers the Signifyd provider with the Yuno SDK.
2. During checkout, if Signifyd is a fraud screening provider for the transaction, the Yuno SDK runs the module with the Signifyd SDK key that Yuno serves for your account.
3. The module profiles the device with Signifyd's Android SDK and returns the Signifyd session ID.
4. The Yuno SDK sends that session ID in the payment's `payment_method.device_fingerprints`, and Yuno forwards it to Signifyd with the order.

If profiling fails or takes longer than the checkout allows, the payment continues without the Signifyd fingerprint.

## What the module adds to your app

* Signifyd's SDK brings `kotlinx-coroutines` 1.8.1 and `kotlinx-serialization-json` 1.6.3, so your app resolves at least those versions.
* The module declares `INTERNET`, and Signifyd's SDK adds the normal permission `com.google.android.providers.gsf.permission.READ_GSERVICES`. Both are merged into your manifest automatically and neither prompts the user.
* The module never requests location. If your app already holds location permission, Signifyd's SDK reads the last known location. Reflect this device data collection in your Google Play Data safety form.
* R8 / ProGuard rules for the module and Signifyd's SDK ship as consumer rules. No manual configuration is required when minifying your app.

> [accordion] Migrating from the legacy com.yuno.fraud-signifyd:yunosignifyd dependency
>
> If your app integrated Signifyd through the former `com.yuno.fraud-signifyd:yunosignifyd` dependency, remove it and add `yuno-sdk-antifraud-signifyd` instead. Do not run Signifyd's profiling yourself when you use this module.

## Troubleshooting

> [accordion] Gradle: 401 Unauthorized or could not find com.signifyd:profiling
>
> Your build could not download Signifyd's SDK. Check that Signifyd's registry is declared as shown in [Installation](#installation) and that `signifydGithubToken` holds a valid token from Signifyd, on your machine and in your CI. If the token expired or was revoked, ask your Signifyd solution engineer for a new one. Apps you already released keep working, because the token is only used at build time.

> [accordion] The module is installed but payments carry no Signifyd fingerprint
>
> Check, in this order:
>
> 1. Signifyd is a fraud screening provider in your Yuno payment route.
> 2. The module registered at startup: filter Logcat by `SignifydAntifraud` and look for the `registered` line.
> 3. Your app is not removing the App Startup provider from the manifest. If it is, run the initializer manually as described in [Activating the module](#activating-the-module).

> [accordion] Logcat: Missing API\_KEY param; skipping Signifyd profiling
>
> Signifyd is enabled for the checkout session, but no Signifyd SDK key is served for your account, so the payment continues without a Signifyd fingerprint. Contact your Yuno TAM.

> [accordion] Crash at runtime with NoSuchMethodError or NoSuchFieldError mentioning com.yuno
>
> Your `android-sdk` is older than 2.29.0. Bump it to 2.29.0 or higher.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.