> ## Documentation Index
> Fetch the complete documentation index at: https://gr4vy.radial-commerce.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Adyen - DuitNow

> Configure DuitNow via Adyen as a payment method in Gr4vy.

**Adyen**

Adyen is a global payment technology company founded in 2006 in Amsterdam, Netherlands. The company provides a single platform for accepting payments across online, mobile, and in-store channels for major enterprises worldwide including Uber, Spotify, and Microsoft.

DuitNow is Malaysia's real-time payments network, developed and managed by PayNet, the country's central payment infrastructure operator. It lets buyers transfer funds between banks and e-wallets using a mobile number, national identification number, or business registration number. Adyen's DuitNow integration supports QR code payments only: the buyer scans a QR code with their banking or e-wallet app to complete the transfer.

## Setup

Please follow the [common Adyen instructions](https://gr4vy.radial-commerce.com/connections/payments/adyen.md) to get set up with DuitNow.

Next, make sure to enable DuitNow as a payment method on your configured account.

## Capabilities

This list is for guidance only. It doesn't guarantee availability or
create any rights, and the provider may need to enable some features for
your account.

## Supported countries

## Supported currencies

## Integration

For DuitNow, the default integration for Adyen is through a redirect to a hosted payments page that displays the QR code for the buyer to scan.

### Redirect integration

Start by creating a new transaction with the following required fields.

```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 1299,
    Currency = "MYR",
    Country = "MY",
    Intent = "capture",
    PaymentMethod =
      TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
        new RedirectPaymentMethodCreate()
        {
          Method = "duitnow",
          Country = "MY",
          Currency = "MYR",
          RedirectUrl = "https://example.com/callback",
        }
      ),
  }
);
```

```go Go theme={"system"}
amount := int64(1299)
currency := "MYR"
country := "MY"
method := components.RedirectPaymentMethodCreateMethodDuitnow
redirectUrl := "https://example.com/callback"

redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
  Method: method,
  Country: country,
  Currency: currency,
  RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:        amount,
  Currency:      currency,
  Country:       &country,
  Intent:       gr4vy.Pointer(components.TransactionIntentCapture),
  PaymentMethod: &paymentMethod,
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```

```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(1299L)
    .currency("MYR")
    .country("MY")
    .intent(TransactionIntent.CAPTURE)
    .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
      .method(RedirectPaymentMethodCreateMethod.DUITNOW)
      .country("MY")
      .currency("MYR")
      .redirectUrl("https://example.com/callback")
      .build()))
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);
```

```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
  amount: 1299,
  currency: 'MYR',
  country: 'MY',
  intent: 'capture',
  paymentMethod: new RedirectPaymentMethodCreate(
    method: 'duitnow',
    country: 'MY',
    currency: 'MYR',
    redirectUrl: 'https://example.com/callback'
  )
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```

```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
  amount=1299,
  currency="MYR",
  country="MY",
  intent="capture",
  payment_method={
    "method": "duitnow",
    "country": "MY",
    "currency": "MYR",
    "redirect_url": "https://example.com/callback",
  }
)
```

```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
  amount: 1299,
  currency: "MYR",
  country: "MY",
  intent: "capture",
  paymentMethod: {
    method: "duitnow",
    country: "MY",
    currency: "MYR",
    redirectUrl: "https://example.com/callback"
  }
})
```

After the transaction is created, the API response includes `payment_method.approval_url` and the `buyer_approval_pending` status.

```json theme={"system"}
{
  "type": "transaction",
  "id": "ea1efdd0-20f9-44d9-9b0b-0a3d71e9b625",
  "payment_method": {
    "type": "payment-method",
    "approval_url": "https://cdn.sandbox.spider.gr4vy.app/connectors/adyen/apm.html?token=..."
  },
  "method": "duitnow"
}
```

Redirect the buyer to the `approval_url` so they can scan the DuitNow QR code and approve the payment from their banking or e-wallet app. After approval, the buyer is redirected to the `redirect_url` you provided when creating the transaction. Do not rely solely on the redirect. Either poll the transaction or (recommended) use webhooks to detect the final status (for example, `capture_succeeded` or failure states).

### Direct integration

Adyen provides [web](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Web\&integration=Components\&version=6.23.0), [Android](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components\&version=5.15.0) and [iOS](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=iOS\&integration=Components\&version=5.21.1) SDKs for a direct integration. For these flows you should indicate the platform by setting an appropriate `integration_client` when creating the transaction, and then build a client-side integration that uses the [`POST /transactions/:transaction_id/session`](https://gr4vy.radial-commerce.com/reference/transactions/get-transaction-session) API to initialize the Adyen SDK.

To start, create a new transaction with the appropriate `integration_client`.

```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 1299,
    Currency = "MYR",
    Country = "MY",
    Intent = "capture",
    IntegrationClient = "ios",
    PaymentMethod =
      TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
        new RedirectPaymentMethodCreate()
        {
          Method = "duitnow",
          Country = "MY",
          Currency = "MYR",
          RedirectUrl = "yourapp://callback",
        }
      ),
  }
);
```

```go Go theme={"system"}
amount := int64(1299)
currency := "MYR"
country := "MY"
integrationClient := "ios"
method := components.RedirectPaymentMethodCreateMethodDuitnow
redirectUrl := "yourapp://callback"

redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
  Method: method,
  Country: country,
  Currency: currency,
  RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:            amount,
  Currency:          currency,
  Country:           &country,
  Intent:           gr4vy.Pointer(components.TransactionIntentCapture),
  IntegrationClient: &integrationClient,
  PaymentMethod:     &paymentMethod,
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```

```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(1299L)
    .currency("MYR")
    .country("MY")
    .intent(TransactionIntent.CAPTURE)
    .integrationClient("ios")
    .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
      .method(RedirectPaymentMethodCreateMethod.DUITNOW)
      .country("MY")
      .currency("MYR")
      .redirectUrl("yourapp://callback")
      .build()))
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);
```

```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
  amount: 1299,
  currency: 'MYR',
  country: 'MY',
  intent: 'capture',
  integrationClient: 'ios',
  paymentMethod: new RedirectPaymentMethodCreate(
    method: 'duitnow',
    country: 'MY',
    currency: 'MYR',
    redirectUrl: 'yourapp://callback'
  )
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```

```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
  amount=1299,
  currency="MYR",
  country="MY",
  intent="capture",
  integration_client="ios",
  payment_method={
    "method": "duitnow",
    "country": "MY",
    "currency": "MYR",
    "redirect_url": "yourapp://callback",
  }
)
```

```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
  amount: 1299,
  currency: "MYR",
  country: "MY",
  intent: "capture",
  integrationClient: "ios",
  paymentMethod: {
    method: "duitnow",
    country: "MY",
    currency: "MYR",
    redirectUrl: "yourapp://callback"
  }
})
```

For mobile, set `integration_client` to `ios` or `android` and use your app deep link for `redirect_url` (for example, `yourapp://`).

After the transaction is created, the API response includes a `session_token` which can be used to get the [session data](https://gr4vy.radial-commerce.com/reference/transactions/get-transaction-session.md) for that transaction.

```sh theme={"system"}
POST /transactions/:transaction_id/session?token=:session_token
```

```json Web theme={"system"}
{
  "session_data": {
    "sessionId": "CS04C0B8AC9849A7D8E25B20D",
    "sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
    "environment": "live",
    "clientKey": "client-key",
    "returnUrl": "https://example.com/callback",
    "paymentMethod": "duitnow",
    "storePaymentMethod": true
  },
  "default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
  "integration_client": "web"
}
```

```json iOS theme={"system"}
{
  "session_data": {
    "sessionId": "CS04C0B8AC9849A7D8E25B20D",
    "sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
    "environment": "live",
    "clientKey": "client-key",
    "returnUrl": "yourapp://",
    "paymentMethod": "duitnow",
    "storePaymentMethod": true
  },
  "default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
  "integration_client": "ios"
}
```

```json Android theme={"system"}
{
  "session_data": {
    "sessionId": "CS04C0B8AC9849A7D8E25B20D",
    "sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
    "environment": "live",
    "clientKey": "client-key",
    "returnUrl": "yourapp://",
    "paymentMethod": "duitnow",
    "storePaymentMethod": true
  },
  "default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
  "integration_client": "android"
}
```

This session data provides the `sessionId` and `sessionData` required to load the Adyen SDK.

```js Web theme={"system"}
const adyenEnvironment = sessionData.environment;
const clientKey = sessionData.clientKey;
const sessionId = sessionData.sessionId;
const adyenSessionData = sessionData.sessionData;
const returnUrl = sessionData.returnUrl;
const paymentMethod = sessionData.paymentMethod;
const storePaymentMethod = sessionData.storePaymentMethod;
const configuration = {
    environment: adyenEnvironment,
    clientKey,
    analytics: {
      enabled: false,
    },
    session: {
      id: sessionId,
      sessionData: adyenSessionData,
    },
}
AdyenCheckout(configuration).then(function (checkout) {
  let component = checkout
    .create(paymentMethod)
    .mount('#component');
  });
```

```swift iOS theme={"system"}
var adyenEnvironment = sessionData.environment;
var clientKey = sessionData.clientKey;
var sessionId = sessionData.sessionId;
var adyenSessionData = sessionData.sessionData;
var returnUrl = sessionData.returnUrl;
var paymentMethod = sessionData.paymentMethod;
var storePaymentMethod = sessionData.storePaymentMethod;

override func viewDidLoad() {
  super.viewDidLoad()

  let configuration = AdyenSession.Configuration(sessionIdentifier: sessionId,
    initialSessionData: adyenSessionData)

  AdyenSession.initialize(with: configuration, delegate: self, presentationDelegate: self) { [weak self] result in
    switch result {
      case let .success(session):
          //Store the session object.
          self?.session = session
      case let .failure(error):
          //Handle the error.
    }
  }
}
```

```kotlin Android theme={"system"}
val adyenEnvironment = sessionData.environment;
val clientKey = sessionData.clientKey;
val sessionId = sessionData.sessionId;
val adyenSessionData = sessionData.sessionData;
val returnUrl = sessionData.returnUrl;
val paymentMethod = sessionData.paymentMethod;
val storePaymentMethod = sessionData.storePaymentMethod;

// Create the session object
val checkoutSession = CheckoutSession(
    session = Session(id = sessionId, sessionData = adyenSessionData),
    environment = Environment.TEST,
    clientKey = clientKey
)

when (result) {
    is CheckoutSessionResult.Success -> handleCheckoutSession(result.checkoutSession)
    is CheckoutSessionResult.Error -> handleError(result.exception)
}
```

#### Complete the transaction

Recommended

On mobile integrations, after the buyer completes the payment flow, the Adyen SDK provides the developer with an `onFinished` call, which includes a `statusCode`.

The system automatically syncs the status through webhooks, but to complete the transaction it is also recommended sending a `GET` request to the `default_completion_url` provided in the session response with the `sessionId` and the `sessionResult` as query parameters to finalize the transaction. This also moves the transaction to a completed status without waiting for the webhook to be sent.

The call returns a `204 No Content` response. After receiving this response, you can also optionally fetch the transaction to confirm final status.

```swift iOS theme={"system"}
func didComplete(with result: AdyenSessionResult,
            component: Component,
            session: AdyenSession)
{
    var urlComponents = URLComponents(string: defaultCompletionUrl)!
    urlComponents.queryItems = [
        URLQueryItem(name: "sessionId", value: session.session.id),
        URLQueryItem(name: "sessionResult", value: result.sessionResult)
    ]

    var request = URLRequest(url: urlComponents.url!)
    request.httpMethod = "GET"
    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        // Handle 204 response, you can now poll the transaction
    }
    task.resume()
}
```

```kotlin Android theme={"system"}
override fun onFinished(result: SessionPaymentResult) {
    val sessionResult = result.sessionResult
    val uri = Uri.parse(defaultCompletionUrl)
        .buildUpon()
        .appendQueryParameter("sessionId", result.sessionId)
        .appendQueryParameter("sessionResult", sessionResult)
        .build()
    val url = URL(uri.toString())
    val urlConnection = url.openConnection() as HttpURLConnection
    urlConnection.requestMethod = "GET"
    val responseCode = urlConnection.responseCode
    if (responseCode == HttpURLConnection.HTTP_NO_CONTENT) {
        // Handle 204 response, you can now poll the transaction
    }
}
```

Please refer to the Adyen documentation for the [web](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Web\&integration=Components\&version=6.23.0), [Android](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components\&version=5.15.0) and [iOS](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=iOS\&integration=Components\&version=5.21.1) for further guidance.

## Testing

Unlike many Adyen test flows, DuitNow does not use dummy test values. Test with real payment details and small amounts, then check the status of the payment in your Adyen Customer Area under **Payments** -> **Payment list**.

Adyen has [further instructions](https://docs.adyen.com/payment-methods/duitnow/web-component/#test-and-go-live) on testing and going live with DuitNow.


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