> ## 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.

> ## Agent Instructions
> Test in the sandbox first: base URL https://api-sandbox.y.uno (Test Mode in the Dashboard). Production is https://api.y.uno (Live Mode).
> Every API request needs the public-api-key and private-secret-key headers. Get them in the Dashboard at https://dashboard.y.uno/developers (Developers > Credentials); sandbox and production keys are different.
> Send an X-Idempotency-Key (a UUID) when creating payments, refunds and cancels, so retries do not create duplicates.
> Start with the Quickstart (https://docs.y.uno/docs/quickstart.md) and the agent guide (https://docs.y.uno/agents.md). To search these docs from a coding agent, connect the docs MCP server at https://docs.y.uno/mcp.

# 3DS Native SDKs (Android)

> Run 3D Secure challenges natively in your Android app with Netcetera's 3DS SDK.

> [!NOTE]
>
> **This page documents a legacy SDK.** Starting a new integration? Use the [Yuno SDK](https://docs.y.uno/docs/yuno-sdk/get-started.md). Already on a legacy SDK? Follow the [migration guide](https://docs.y.uno/docs/yuno-sdk/migration/overview.md).
>
> The new **Yuno SDK** (Web v2.x, iOS v3.x, Android v3.x, React Native v2.x) replaces the Full, Lite, Seamless, Render, Headless, and Secure Fields SDKs with one API across every platform. Legacy SDKs remain supported side by side during the transition and are scheduled for deprecation in **2027**. Contact your Account Manager for migration planning.

The Yuno Android SDK supports running 3D Secure (3DS) challenges natively inside your app using **Netcetera's 3DS SDK**. Native 3DS gives a smoother UX than the WebView-based fallback (no in-app browser jump) and may be required by some acquirers for frictionless authentication.

> [!NOTE]
>
> Native 3DS via Netcetera applies to both **payment** and **enrollment** flows (enrollment since Yuno Android SDK 2.22.0).

> [!NOTE]
>
> Native 3DS is **opt-in**: you only need to install the provider module if your integration runs 3DS challenges in-app. If you are not enabling 3DS, you can skip this guide.

> [!NOTE]
>
> This is a separate module (roughly 3-4 MB) so you only add it if you need native 3DS. If your app already customizes the Yuno SDK's styles, those styles propagate automatically to the challenge screen, no additional UI configuration is needed.

This guide covers what is specific to Netcetera. Installation and activation follow 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 level 23)** or higher, the minimum of the Yuno Android SDK since 2.24.0.
* **Yuno Payments SDK 2.16.0 or higher** already installed in your app (`com.yuno.payments:android-sdk`).
* The Netcetera 3DS provider module (`com.yuno.payments:yuno-sdk-3ds-netcetera`), installed via Gradle (see below).

## Compatibility

Each release of this module is built and tested against a minimum version of the Yuno Payments SDK. The module's POM does not pin a specific core version. Versions below the minimum may not expose the APIs this module relies on and can fail at runtime with `NoSuchMethodError` / `NoSuchFieldError`.

| Yuno 3DS Netcetera | Requires Yuno Payments SDK |
| - | - |
| `1.0.1` | `≥ 2.16.0` |

When upgrading either dependency, bump both sides together so the combination stays within a supported pair.

## Step 1: Declare the Netcetera Maven repository

The Netcetera 3DS SDK is hosted on Netcetera's public Maven server. Because Gradle does not propagate transitive repositories through POM metadata, your app must declare the repo explicitly so it can resolve the Netcetera SDK dependency.

Add the entry to your project's settings file inside `dependencyResolutionManagement.repositories`:

> [tab] Groovy DSL
>
> In `settings.gradle`:
>
> ```groovy theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencyResolutionManagement {
>     repositories {
>         google()
>         mavenCentral()
>         maven { url "https://yunopayments.jfrog.io/artifactory/snapshots-libs-release" }
>         // Required by Yuno 3DS Netcetera module
>         maven { url "https://nexus.extranet.netcetera.biz/nexus/repository/public-repository-maven/" }
>     }
> }
> ```

> [tab] Kotlin DSL
>
> In `settings.gradle.kts`:
>
> ```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencyResolutionManagement {
>     repositories {
>         google()
>         mavenCentral()
>         maven { url = uri("https://yunopayments.jfrog.io/artifactory/snapshots-libs-release") }
>         // Required by Yuno 3DS Netcetera module
>         maven { url = uri("https://nexus.extranet.netcetera.biz/nexus/repository/public-repository-maven/") }
>     }
> }
> ```

> [!NOTE]
>
> You may still be using the legacy `allprojects { repositories { … } }` block in your root `build.gradle`. If so, add the same Netcetera `maven { url "…" }` line there instead.

## Step 2: Add the dependency

Add the Yuno 3DS Netcetera dependency to your app module's build file:

> [tab] Groovy DSL
>
> In `build.gradle`:
>
> ```groovy theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> dependencies {
>     implementation "com.yuno.payments:android-sdk:2.27.0"
>     implementation "com.yuno.payments:yuno-sdk-3ds-netcetera:1.0.1"
> }
> ```

> [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.27.0")
>     implementation("com.yuno.payments:yuno-sdk-3ds-netcetera:1.0.1")
> }
> ```

The upstream Netcetera 3DS SDK wrapped by `yuno-sdk-3ds-netcetera` and its required `androidx.startup` dependency are pulled in transitively. You don't need to declare them yourself.

## Activating the 3DS provider

The module **auto-registers** with the Yuno Payments SDK when your app process starts (via [Jetpack App Startup](https://developer.android.com/topic/libraries/app-startup)). **No extra code is required**: just initialize the Yuno SDK as usual:

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import com.yuno.sdk.Yuno

Yuno.initialize(
    applicationContext = this,
    apiKey = "YOUR_API_KEY",
)
```

> [!TIP]
>
> Once registered, the Yuno Payments SDK automatically routes any 3DS challenge during checkout or enrollment through the Netcetera provider.

### Permissions

`android.permission.INTERNET` is declared by the module's manifest and merged into your app automatically. No action required.

## Sandbox certificate

When testing against the Yuno sandbox environment, the Netcetera SDK requires a card scheme certificate to be present in your app.

> [!NOTE]
>
> **Contact your Yuno TAM (Technical Account Manager) to obtain the certificate.** It is not distributed publicly.

This is only required for sandbox testing, not for production.


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