---
title: "TrueMoney Component"
description: "Add TrueMoney to an existing Components integration."
url: "https://docs.adyen.com/payment-methods/truemoney/web-component"
source_url: "https://docs.adyen.com/payment-methods/truemoney/web-component.md"
canonical: "https://docs.adyen.com/payment-methods/truemoney/web-component"
last_modified: "2021-10-18T17:19:00+02:00"
language: "en"
---

# TrueMoney Component

Add TrueMoney to an existing Components integration.

This page explains how to add TrueMoney to your existing Components integration.

## Requirements

Select the [server-side flow](https://docs.adyen.com/online-payments/build-your-integration) that your integration uses:

### Tab: Sessions flow

| Requirement          | Description                                                                                                                                                                                                                       |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built a Sessions flow [Components integration](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=%7B%7BgetParameter%28%27platform%27%29%7D%7D\&integration=Components). |
| **Setup steps**      | Before you begin, [add TrueMoney in your Customer Area](https://docs.adyen.com/payment-methods/add-payment-methods).                                                                                                               |

### Tab: Advanced flow

| Requirement          | Description                                                                                                                                                                                                                        |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built an Advanced flow [Components integration](https://docs.adyen.com/online-payments/build-your-integration/advanced-flow?platform=%7B%7BgetParameter%28%27platform%27%29%7D%7D\&integration=Components). |
| **Setup steps**      | Before you begin, [add TrueMoney in your Customer Area](https://docs.adyen.com/payment-methods/add-payment-methods).                                                                                                                |

## API reference

You do not need to send additional fields for TrueMoney. To see optional fields that you can send for all payment methods, choose the endpoint you integrated:

* [/sessions](https://docs.adyen.com/api-explorer/Checkout/latest/post/sessions): This is the default with [Components v5.0.0](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Web\&integration=Components) or later.
* [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments): If you implemented an [additional use case](https://docs.adyen.com/online-payments/build-your-integration).

## Component configuration

### Step 1: Create a DOM element

Create a DOM element on your checkout page, placing it where you want the payment method form to be rendered:

```html
 <div id="true_money-container"></div>
```

### Step 2: Create an instance of the Component

#### v6.0.0 or later

Create an instance of the Component, passing:

* Your instance of `AdyenCheckout`.

```js
const trueMoney = new Redirect(checkout, { type: 'true_money' }).mount('#true_money-container');
```

**

#### v5.x.x or earlier

Use the `create` method of your `AdyenCheckout` instance, in this case `checkout`, to create the Component:

```js
const trueMoneyComponent = checkout.create('true_money').mount('#true_money-container');
```

## Recurring

TrueMoney supports recurring transactions. To make recurring transactions, you need to:

1. [Create a shopper token](https://docs.adyen.com/payment-methods/truemoney/web-component#create-a-token).
2. [Use the token to make future payments for the shopper](https://docs.adyen.com/payment-methods/truemoney/web-component#make-payment-with-token).

### Create a token

To create a token, include in your [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request:

* `storePaymentMethod`: **true**
* [shopperReference](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#request-shopperReference): Your unique identifier for the shopper.

This triggers the [recurring flow](https://docs.adyen.com/payment-methods/truemoney/api-only#recurring-payments), where the shopper logs in to their TrueMoney account, and then confirms the recurring transaction.

For the recurring flow to be completed, always make the [/payments/details](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments/details) request, otherwise the payment method will not be stored.

When the payment has been settled, you receive a [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) [webhook](https://docs.adyen.com/development-resources/webhooks) containing:

* `type`: **recurring.token.created**
* `shopperReference`: your unique identifier for the shopper.
* `eventId`: the `pspReference` of the initial payment.
* `storedPaymentMethodId`: the token that you need to make recurring payments for this shopper.

Make sure that your server is able to receive the [Recurring tokens life cycle events](https://docs.adyen.com/development-resources/webhooks/webhook-types/#other-webhooks) webhook. You can [set up this webhook in your Customer Area](https://docs.adyen.com/development-resources/webhooks/#set-up-webhooks-in-your-customer-area).

### Make a payment with a token

To make a payment with the token, include in your [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request:

* `paymentMethod.storedPaymentMethodId`: The `storedPaymentMethodId` from the [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) webhook or from `additionalData.tokenization.storedPaymentMethodId` if you are retrieving the token synchronously.

  You can also get this value using the [/listRecurringDetails](https://docs.adyen.com/api-explorer/Recurring/latest/post/listRecurringDetails) endpoint.

* `shopperReference`: The unique shopper identifier that you specified when creating the token.

* `shopperInteraction`: **ContAuth**

* `recurringProcessingModel`: Use **Subscription** for a series of transactions following a fixed time interval or **UnscheduledCardOnFile** for contracts with non-fixed time interval.

  #### curl

  ```bash
  curl https://checkout-test.adyen.com/v68/payments \
  -H 'x-api-key: ADYEN_API_KEY' \
  -H 'content-type: application/json' \
  -d '{
         "amount":{
            "value":1000,
            "currency":"THB"
         },
         "paymentMethod":{
            "type":"truemoney",
            "storedPaymentMethodId":"7219687191761347"
         },
         "reference":"YOUR_ORDER_NUMBER",
         "merchantAccount":"ADYEN_MERCHANT_ACCOUNT",
         "shopperReference":"YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
         "shopperInteraction":"ContAuth",
         "recurringProcessingModel": "Subscription"
  }'
  ```

  #### Java

  ```java
  // Adyen Java API Library v27.0.0
  import com.adyen.Client;
  import com.adyen.enums.Environment;
  import com.adyen.model.checkout.*;
  import java.time.OffsetDateTime;
  import java.util.*;
  import com.adyen.model.RequestOptions;
  import com.adyen.service.checkout.*;

  // For the live environment, additionally include your liveEndpointUrlPrefix.
  Client client = new Client("ADYEN_API_KEY", Environment.TEST);

  // Create the request object(s)
  Amount amount = new Amount()
    .currency("THB")
    .value(1000L);

  StoredPaymentMethodDetails storedPaymentMethodDetails = new StoredPaymentMethodDetails()
    .storedPaymentMethodId("7219687191761347")
    .type(StoredPaymentMethodDetails.TypeEnum.TRUEMONEY);

  PaymentRequest paymentRequest = new PaymentRequest()
    .reference("YOUR_ORDER_NUMBER")
    .amount(amount)
    .merchantAccount("ADYEN_MERCHANT_ACCOUNT")
    .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.SUBSCRIPTION)
    .paymentMethod(new CheckoutPaymentMethod(storedPaymentMethodDetails))
    .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
    .shopperReference("YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j");

  // Send the request
  PaymentsApi service = new PaymentsApi(client);
  PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
  ```

  #### PHP

  ```php
  // Adyen PHP API Library v19.0.0
  use Adyen\Client;
  use Adyen\Environment;
  use Adyen\Model\Checkout\Amount;
  use Adyen\Model\Checkout\CheckoutPaymentMethod;
  use Adyen\Model\Checkout\PaymentRequest;
  use Adyen\Service\Checkout\PaymentsApi;

  $client = new Client();
  $client->setXApiKey("ADYEN_API_KEY");
  // For the live environment, additionally include your liveEndpointUrlPrefix.
  $client->setEnvironment(Environment::TEST);


  // Create the request object(s)
  $amount = new Amount();
  $amount
    ->setCurrency("THB")
    ->setValue(1000);

  $checkoutPaymentMethod = new CheckoutPaymentMethod();
  $checkoutPaymentMethod
    ->setStoredPaymentMethodId("7219687191761347")
    ->setType("truemoney");

  $paymentRequest = new PaymentRequest();
  $paymentRequest
    ->setReference("YOUR_ORDER_NUMBER")
    ->setAmount($amount)
    ->setMerchantAccount("ADYEN_MERCHANT_ACCOUNT")
    ->setRecurringProcessingModel("Subscription")
    ->setPaymentMethod($checkoutPaymentMethod)
    ->setShopperInteraction("ContAuth")
    ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j");

  $requestOptions['idempotencyKey'] = 'UUID';

  // Send the request
  $service = new PaymentsApi($client);
  $response = $service->payments($paymentRequest, $requestOptions);
  ```

  #### C\#

  ```cs
  // Adyen .net API Library v17.0.0
  using Adyen;
  using Environment = Adyen.Model.Environment;
  using Adyen.Model;
  using Adyen.Model.Checkout;
  using Adyen.Service.Checkout;

  // For the live environment, additionally include your liveEndpointUrlPrefix.
  var config = new Config()
  {
      XApiKey = "ADYEN_API_KEY",
      Environment = Environment.Test
  };
  var client = new Client(config);

  // Create the request object(s)
  Amount amount = new Amount
  {
    Currency = "THB",
    Value = 1000
  };

  StoredPaymentMethodDetails storedPaymentMethodDetails = new StoredPaymentMethodDetails
  {
    StoredPaymentMethodId = "7219687191761347",
    Type = StoredPaymentMethodDetails.TypeEnum.Truemoney
  };

  PaymentRequest paymentRequest = new PaymentRequest
  {
    Reference = "YOUR_ORDER_NUMBER",
    Amount = amount,
    MerchantAccount = "ADYEN_MERCHANT_ACCOUNT",
    RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
    PaymentMethod = new CheckoutPaymentMethod(storedPaymentMethodDetails),
    ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
    ShopperReference = "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"
  };

  // Send the request
  var service = new PaymentsService(client);
  var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
  ```

  #### NodeJS (JavaScript)

  ```js
  // Adyen Node API Library v18.0.0
  // Require the parts of the module you want to use
  const { Client, CheckoutAPI } = require('@adyen/api-library');
  // Initialize the client object
  // For the live environment, additionally include your liveEndpointUrlPrefix.
  const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

  // Create the request object(s)
  const paymentRequest = {
    amount: {
      value: 1000,
      currency: "THB"
    },
    paymentMethod: {
      type: "truemoney",
      storedPaymentMethodId: "7219687191761347"
    },
    reference: "YOUR_ORDER_NUMBER",
    merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
    shopperReference: "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
    shopperInteraction: "ContAuth",
    recurringProcessingModel: "Subscription"
  }

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

  #### Go

  ```go
  // Adyen Go API Library v10.4.0
  import (
    "context"
    "github.com/adyen/adyen-go-api-library/v9/src/common"
    "github.com/adyen/adyen-go-api-library/v9/src/adyen"
    "github.com/adyen/adyen-go-api-library/v9/src/checkout"
  )
  // For the live environment, additionally include your liveEndpointUrlPrefix.
  client := adyen.NewClient(&common.Config{
    ApiKey:      "ADYEN_API_KEY",
    Environment: common.TestEnv,
  })

  // Create the request object(s)
  amount := checkout.Amount{
    Currency: "THB",
    Value: 1000,
  }

  storedPaymentMethodDetails := checkout.StoredPaymentMethodDetails{
    StoredPaymentMethodId: common.PtrString("7219687191761347"),
    Type: common.PtrString("truemoney"),
  }

  paymentRequest := checkout.PaymentRequest{
    Reference: "YOUR_ORDER_NUMBER",
    Amount: amount,
    MerchantAccount: "ADYEN_MERCHANT_ACCOUNT",
    RecurringProcessingModel: common.PtrString("Subscription"),
    PaymentMethod: checkout.StoredPaymentMethodDetailsAsCheckoutPaymentMethod(&storedPaymentMethodDetails),
    ShopperInteraction: common.PtrString("ContAuth"),
    ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"),
  }

  // Send the request
  service := client.Checkout()
  req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
  res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
  ```

  #### Python

  ```py
  # Adyen Python API Library v12.5.1
  import Adyen

  adyen = Adyen.Adyen()
  adyen.client.xapikey = "ADYEN_API_KEY"
  # For the live environment, additionally include your liveEndpointUrlPrefix.
  adyen.client.platform = "test" # The environment to use library in.

  # Create the request object(s)
  json_request = {
    "amount": {
      "value": 1000,
      "currency": "THB"
    },
    "paymentMethod": {
      "type": "Truemoney",
      "storedPaymentMethodId": "7219687191761347"
    },
    "reference": "YOUR_ORDER_NUMBER",
    "merchantAccount": "ADYEN_MERCHANT_ACCOUNT",
    "shopperReference": "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
    "shopperInteraction": "ContAuth",
    "recurringProcessingModel": "Subscription"
  }

  # Send the request
  result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
  ```

  #### Ruby

  ```rb
  # Adyen Ruby API Library v9.1.0
  require "adyen-ruby-api-library"

  adyen = Adyen::Client.new
  adyen.api_key = 'YOUR_X_API_KEY'
  adyen.env = :test # Set to "live" for live environment

  request_body = {
    :amount => {
      :value => 1000,
      :currency => 'THB'
    },
    :paymentMethod => {
      :type => 'true_money',
      :storedPaymentMethodId => '7219687191761347'
    },
    :reference => 'YOUR_ORDER_NUMBER',
    :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
    :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j',
    :shopperInteraction => 'ContAuth',
    :recurringProcessingModel => 'Subscription'
  }

  result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
  ```

  #### NodeJS (TypeScript)

  ```ts
  // Adyen Node API Library v18.0.0
  // Require the parts of the module you want to use
  import { Client, CheckoutAPI, Types } from "@adyen/api-library";
  // Initialize the client object
  // For the live environment, additionally include your liveEndpointUrlPrefix.
  const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

  // Create the request object(s)
  const amount: Types.checkout.Amount = {
    currency: "THB",
    value: 1000
  };

  const storedPaymentMethodDetails: Types.checkout.StoredPaymentMethodDetails = {
    storedPaymentMethodId: "7219687191761347",
    type: Types.checkout.StoredPaymentMethodDetails.TypeEnum.Truemoney
  };

  const paymentRequest: Types.checkout.PaymentRequest = {
    reference: "YOUR_ORDER_NUMBER",
    amount: amount,
    merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
    recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
    paymentMethod: storedPaymentMethodDetails,
    shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
    shopperReference: "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"
  };

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

## Test and go live

To test successful TrueMoney live payments, you need to use a real mobile number registered with a [TrueMoney account](https://www.truemoney.com).

If you are encountering issues with testing TrueMoney payments, contact our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other).

Check the status of TrueMoney test payments in your [Customer Area](https://ca-test.adyen.com/) > **Payments** > **Payment list**.

Before you can accept live TrueMoney payments, you need to submit a request for TrueMoney in your [live Customer Area](https://ca-live.adyen.com/).