Diller Tap2ID — POS Integration Guide

Audience: External POS developers integrating Diller loyalty via payment terminals

Last Updated: February 2026

Tap2ID allows loyalty members to identify themselves at the point of sale by simply tapping their payment card on the terminal — no phone number, no app, no barcode needed. The POS reads the card, matches it to a Diller loyalty member, fetches their coupons and benefits, applies discounts to the basket, and then charges the final amount — all in a seamless checkout experience.

This guide covers how to integrate Tap2ID into your POS system using two terminal families:

Nets (Ingenico/Baxi) — Uses BAXI.NET SDK with SendJson and DAM/Storebox for card identification

Verifone P630 — Uses PaymentSdk (PSDK) with Card Acquisition and tokenization

Both follow the same high-level flow but use different SDK calls to obtain the card identifier.

The checkout flow with Tap2ID follows these four key steps:

Step 1: Card Read (no charge)

The terminal reads the card and returns a token/member identifier without charging the card. For Nets, the terminal sends a SendJson request with GetAsset action 193. For Verifone, Card Acquisition with tokenRequest: true is used.

Step 2: Diller Lookup

The POS sends the identifier to the Diller API to retrieve member details and available coupons.

Step 3: Apply Benefits

The POS applies the member's available coupons and discounts to the basket, then calculates the final amount. For example, 349 NOK might be reduced to 299 NOK after discount.

Step 4: Payment (card charged)

The terminal processes a normal payment transaction for the discounted total. The customer taps or inserts their card again and may enter a PIN.

Note: The member must have pre-registered their card in the loyalty system. If the card is not recognized, the POS can fall back to phone number lookup and then register the card for future Tap2ID use.

Prerequisites

BAXI.NET SDK (baxi_dotnet.dll v1.14.1 or later) — available from NexiGroup

Terminal with Storebox/DAM support enabled (contact Nets/NexiGroup)

PreventLoyaltyFromPurchase property set to 0 on the BaxiCtrl instance

UseExtendedLocalMode property set to 1

Diller API credentials (client_id, client_secret, store_id)

At the start of checkout, send a SendJson call to the terminal with a GetAsset (action 193) request. This prompts the customer to tap their card. The terminal reads the card and queries Storebox for a linked member ID — without charging the card.

SendJson Request Example

The JSON payload should include the following structure with the GetAsset action and Storebox template:

Key Fields:

• type: 101 — Asset query message type

• action: 193 — GetAsset (read card and fetch linked data)

• mode: 4 — Transaction + asset lookup mode

• amount — The basket total in øre (cents). 349.00 NOK = "34900"

• txntype: "30" — Indicates a purchase context

• requestid — A unique request identifier (e.g., timestamp + random)

• template.name: "storebox" — Target the Storebox DAM system

• cardref: "<cardref.001>" — Literal placeholder (terminal replaces with actual card reference after tap)

Important: The <cardref.001> value must be sent as a literal string including the angle brackets. Ensure your JSON serializer does not escape the < and > characters.

In code, calling SendJson:

var args = new SendJsonEventArgs { JsonString = jsonPayload };

_baxi.SendJson(args);

Response: The terminal fires the OnLocalMode event when the customer taps their card. The response contains the DAM data including the member identifier in the attributes payload.

After applying discounts and calculating the final amount, perform a standard TransferAmount call to charge the card:

Example TransferAmount Call:

var args = new TransferAmountEventArgs {

OperID = "0000",

Type1 = 0x30, // Purchase

Amount1 = 29900, // 299 NOK in øre (cents) — the discounted total

Type2 = 0x30,

Amount2 = 0,

Type3 = 0x30,

Amount3 = 0,

HostData = "",

ArticleDetails = "",

PaymentConditionCode = "",

AuthCode = ""

};

_baxi.TransferAmount(args);

// Wait for OnLocalMode event — customer taps/inserts card and enters PIN

Key Parameters:

• Type1 = 0x30 — Purchase transaction (0x31 for refund)

• Amount1 — Amount in øre (cents). 299.00 NOK = 29900

The OnLocalMode event fires when the transaction completes, providing the result, truncated PAN, auth code, timestamp, and terminal ID. After successful payment, sync the transaction to Diller using the Create Transaction endpoint (see Diller API Reference section).

If the Storebox lookup returns no member data (card not registered), you can ask the customer for their phone number, search Diller by phone, and if found, link the card to the member using InsertAsset (action 191).

The InsertAsset request has the same JSON structure as GetAsset but uses action 191. Key fields include:

• action: 191 — InsertAsset (associate card with member)

• msisdn — Member's phone number with country code (e.g., "4712345678" for Norway)

• memberno — Diller member ID (from the phone search result)

• cardref: "<cardref.001>" — Terminal replaces with the tapped card's reference

The terminal prompts the customer to tap their card. On success, the card → member link is stored in Storebox, and future taps will return the member ID automatically. Check statustext === "OK" to confirm the card was registered successfully.

The PaymentSdk must be initialized and a session must be active before performing card acquisition. The initialization sequence is:

1. Initialize SDK → PaymentSdk.InitializeFromValues(listener, params)

2. 2. Login → TransactionManager.LoginWithCredentials(credentials)

3. 3. Start Session → TransactionManager.StartSession(transaction)

4. 4. Card Acquisition → TransactionManager.RequestCardData2(request)

Example Card Acquisition Call:

var request = CardAcquisitionRequest.Create(

tokenRequest: true, // IMPORTANT: Request tokenization

message: "Please tap card", // Terminal display message

presentationMethods: new[] {

CardPresentationMethod.CTLS_CARD, // Contactless

CardPresentationMethod.CHIP, // Chip insert

CardPresentationMethod.MAG_STRIPE // Swipe (fallback)

}

);

_transactionManager.RequestCardData2(request);

// Wait for CardInformationReceivedEvent callback (up to 60 seconds)

Critical: tokenRequest: true is essential — it tells the Verifone system to generate tokens for the card. Without this, you will not get the identifier needed for Diller. Tokenization must also be enabled on the backend/terminal configuration through Verifone support.

When the customer taps their card, the SDK fires the HandleCardInformationReceivedEvent callback. Extract the card data as follows:

public override void HandleCardInformationReceivedEvent(CardInformationReceivedEvent evt) {

var cardInfo = evt.CardInformation;

// Card details

string brand = cardInfo.PaymentBrand; // "VISA", "MASTERCARD", etc.

string panLast4 = cardInfo.PanLast4; // "1234"

string expiry = cardInfo.CardExpiry; // "2612" (YYMM)

// Tokens — this is what you send to Diller

var tokens = cardInfo.Tokens; // Array of token objects

foreach (var token in tokens) {

string type = token.TokenType; // "ANALYTICS", "REUSE", etc.

string value = token.Value; // The token string

string scheme = token.Scheme; // "VISA", etc.

}

// PanHandle — alternative identifier

string panHandle = cardInfo.PanHandle;

}

Token Types:

• ANALYTICS — Persistent card identifier generated by Verifone backend (preferred for Diller)

• REUSE — Token for reusing the card in subsequent transactions (fallback if ANALYTICS not available)

Use the ANALYTICS token (or REUSE as fallback) as the card identifier for Diller member lookup.

With the ANALYTICS token from card acquisition, query the Diller API to look up the member and retrieve available coupons. Display the coupons to the cashier and apply selected discounts to the basket before proceeding to payment.

After discounts are applied, process payment using the standard PaymentSdk flow. Create a Payment object with the final discounted amount and currency code. The currency should be passed as ISO 4217 numeric code (e.g., 578 for NOK, 752 for SEK, 978 for EUR).

Then call StartPayment with the payment object. The customer will be prompted to tap or insert their card again and may need to enter a PIN. Wait for the PaymentCompletedEvent callback (up to 90 seconds) for the result.

After successful payment, sync the transaction to Diller using the Create Transaction API endpoint (see Diller API Reference section below).

If the Diller API returns no member for the ANALYTICS token (card not registered), you can ask the customer for their phone number, search Diller by phone, and if a member is found, register the card token to that member.

Send a POST request to register the card. The request body should include the ANALYTICS token, card brand (uppercase), and expiry date in YY-MM format.