Skip to main content

3DS Integration at Tuna#

Tuna has its own MPI (Merchant Plug-In) powered by Cybersource/Cardinal Cruise (Visa), which means you don't need to integrate with an external MPI provider. The 3DS authentication layer is handled transparently by Tuna's platform, and Cybersource is Tuna's 3DS provider under the hood — which is why several concepts in this guide (device data collection, step-up challenge, JWT) map directly to Cybersource Payer Authentication and Cardinal Cruise terminology.

3DS is activated on a per-merchant basis, according to each customer's risk and conversion strategy. The decision to use 3DS, and for which payment flows, is configured in Tuna Console's no-code flow editor. If you need help enabling or tuning 3DS for your account, contact your Account Manager or the Tuna Support team.

Not sure which integration mode to use?

If you use Tuna Checkout (hosted payment link or embedded), skip to the Tuna Checkout section — just configure your flow.

If you are on VTEX, skip to the VTEX section — it only takes one step. For all other platforms, choose one of the four direct integration modes below.


How 3DS works at Tuna#

A 3DS payment is composed of up to six steps. Steps 5–6 only happen when the issuer decides a challenge is required (the step-up flow); for frictionless authentications the payment finishes at step 4.

3DS sequence diagram: Backend calls NewSession; Frontend calls Token/Generate with the 3DS code and runs device data collection; Backend calls Payment/Init; when a challenge is required the response carries threeDSInfo which the frontend renders as an iframe, and the final status is obtained via polling or webhooks
#StepWho runs itEndpoint / action
1Create a sessionBackendPOST /api/Token/NewSession
2Tokenize the card with a 3DS codeFrontendPOST /api/Token/Generate
3Device data collectionFrontendHidden iframe POST to Cardinal
4Call Payment/InitBackendPOST /api/Payment/Init
5Render the challengeFrontendiframe POST to threeDSInfo.url
6Confirm the resultBackendPOST /api/Payment/Status or webhooks
Where does each field go?

The most common 3DS integration mistakes are sending the wrong field to the wrong endpoint. Use the 3DS field reference as your map — it tells you exactly where each value is produced and where it must be sent.


3DS field reference: what to send where#

Fields you create#

FieldWhere you create itWhere you send itDescription
code (authentication reference code)Your frontend — any random string of up to 50 charactersToken/Generate → AuthenticationInformation.Code, then the same value in Payment/Init → authenticationInformation.codeCorrelates the 3DS setup made during tokenization with the payment. Must be identical in both calls.

Fields returned by Token/Generate (3DS setup response)#

When you pass AuthenticationInformation.Code to Token/Generate, the response includes an authenticationInformation object with the Cardinal payer-auth setup data:

FieldWhat it isWhat to do with it
authenticationInformation.accessTokenCardinal JWT for device data collectionPOST it as JWT to deviceDataCollectionUrl in a hidden iframe (step 3). Do not send it to Payment/Init.
authenticationInformation.deviceDataCollectionUrlCardinal device data collection endpointTarget of the hidden iframe form POST (step 3).
authenticationInformation.referenceIdCardinal/Cybersource reference ID of the payer-auth setupSend to Payment/Init → authenticationInformation.referenceId.
authenticationInformation.transactionIdCardinal/Cybersource authentication transaction IDSend to Payment/Init → authenticationInformation.transactionId.
tokenThe card tokenSend to Payment/Init → cardInfo.token.

Fields your backend sends to Payment/Init#

FieldSourceNotes
authenticationInformation.codeThe same code you sent to Token/GenerateRequired
authenticationInformation.referenceIdToken/Generate responseRequired
authenticationInformation.transactionIdToken/Generate responseRequired
cardInfo.tokenToken/Generate responseRequired
frontData.*Collected on the frontend, forwarded by your backendStrongly recommended — see browser/device data
Don't confuse the two transactionIds

Token/Generate returns authenticationInformation.transactionId (the 3DS authentication transaction). Payment/Init responses contain a different, unrelated transactionId (the acquirer transaction). Only the first one goes into Payment/Init's authenticationInformation.

Fields returned by Payment/Init — how the 3DS response differs#

A 3DS Payment/Init response has the same base structure as any other Init response (see the Init API reference), with one key difference: when the issuer requires a challenge, the method comes back pending with a threeDSInfo object that your frontend must use to render the challenge.

Outcomemethods[].statusExtra data in responseWhat to do
Frictionless — authenticated without user interactionFinal status (e.g. 1 authorized, 2 captured)None (no threeDSInfo)Nothing — treat as a regular card payment
Challenge required (step-up)P or 0 (pending)threeDSInfo objectRender the challenge (step 5), then confirm via Status/webhooks
Authentication failed4 (not authorized) or similar error statusNoneAsk the customer for another payment method

The threeDSInfo object:

FieldDescription
threeDSInfo.urlThe ACS step-up URL. Render it inside an iframe by POSTing a form to it.
threeDSInfo.tokenJWT that must be POSTed to url as a form field named JWT.
threeDSInfo.paRequestBase64-encoded challenge request. Decode it to read challengeWindowSize and size the iframe correctly.
threeDSInfo.providerThe MPI provider (e.g. CyberSource).
Payment/Init response when a challenge is required (excerpt)
{
"status": "P",
"methods": [
{
"methodType": "1",
"status": "P",
"methodId": 0,
"threeDSInfo": {
"url": "https://centinelapistag.cardinalcommerce.com/V2/Cruise/StepUp",
"provider": "CyberSource",
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
"paRequest": "eyJtZXNzYWdlVHlwZSI6IkNSZXEiLCJtZXNzYWdlVmVyc2lvbiI6IjIuMi4wIiwi..."
}
}
],
"paymentKey": "13489A900000BC4",
"code": 1
}

Integration modes#

There are four integration approaches available in our official Postman collection. All of them follow the same six steps — they differ only in who performs each step:

ModeWho tokenizes?Who calls Payment/Init?Who renders the challenge?Best for
3DS with pure JSYour frontend formYour backendYour frontend (manual iframe)Full control, custom UI
3DS using tuna.js for tokenizationtuna.js (frontend)Your backendYour frontend (manual iframe or open3dsModal)Simplify PCI scope on frontend
3DS using tuna.js for all interactionstuna.js (frontend)tuna.js (frontend)tuna.js (automatic)Fastest integration, full delegation
3DS with manual tokenizationYour frontend (JS)Your backendYour frontend (manual iframe)Direct control over card capture and tokenization

Step 1 — Create a session (backend)#

The first step is always the same regardless of integration mode: create a Token session via your backend.

note

Always create sessions from your backend — never expose your apptoken on the frontend.

curl -X POST https://token.tunagateway.com/api/Token/NewSession \
-H 'Content-Type: application/json' \
-H 'x-tuna-account: YOUR_ACCOUNT' \
-H 'x-tuna-apptoken: YOUR_APP_TOKEN' \
-d '{
"Customer": {
"ID": "customer-123",
"Email": "maria@example.com"
},
"PaymentAccount": "YOUR_ACCOUNT",
"partneruniqueid": "ORDER-001",
"Is3dsTest": true
}'

Set Is3dsTest: true while testing in the sandbox. Remove it (or set to false) in production.

Step 2 — Tokenize the card with a 3DS code (frontend)#

Your frontend calls POST https://token.tunagateway.com/api/Token/Generate via JavaScript, passing the card data and an AuthenticationInformation.Code — a random string of up to 50 characters generated by you. Sending this code is what triggers the 3DS payer-auth setup at Cybersource; without it, no authenticationInformation is returned and the payment will not be authenticated.

PCI DSS requirement

Token/Generate — and any API that handles raw card data — must be called from the browser (frontend JS), not from your backend server, unless your company holds a PCI DSS Level 1 certification. This is why NewSession is always called from the backend (it only handles non-sensitive identifiers), while Token/Generate is called from the frontend.

{
"SessionId": "{{sessionId}}",
"Card": {
"CardNumber": "4000000000002701",
"CardHolderName": "Maria Silva",
"ExpirationMonth": 1,
"ExpirationYear": 2029,
"CVV": "123",
"SingleUse": false
},
"AuthenticationInformation": {
"Code": "my-random-auth-code-ORDER-001"
}
}

Step 3 — Device data collection (frontend)#

Before calling Payment/Init, the browser must run Cardinal's device data collection: a hidden iframe that POSTs the accessToken (as a field named JWT) to the deviceDataCollectionUrl. This lets the issuer fingerprint the device, which increases frictionless approval rates.

<iframe name="ddc-iframe" height="1" width="1" style="display: none;"></iframe>
<form id="ddc-form" target="ddc-iframe" method="POST"
action="{{deviceDataCollectionUrl}}">
<input type="hidden" name="JWT" value="{{accessToken}}" />
</form>
<script>
document.getElementById("ddc-form").submit();
// Cardinal posts a message to the window when profiling completes
window.addEventListener("message", (event) => {
if (event.origin.includes("cardinalcommerce.com")) {
const data = JSON.parse(event.data);
if (data.MessageType === "profile.completed") {
// Safe to proceed with Payment/Init
}
}
});
</script>

If you use tuna.js, the create3DSDataCollectionFrame method does all of this for you. See Cybersource's device data collection documentation for details on what is collected.

Step 4 — Call Payment/Init (backend)#

After device data collection completes, your frontend sends code, referenceId, transactionId, and the card token to your backend, which calls POST https://engine.tunagateway.com/api/Payment/Init:

{
"TokenSession": "{{sessionId}}",
"PartnerUniqueId": "ORDER-001",
"Customer": {
"ID": "customer-123",
"Name": "Maria Silva",
"Email": "maria@example.com",
"Document": "744.479.870-23",
"DocumentType": "CPF"
},
"PaymentItems": {
"Items": [
{
"Amount": 100,
"ProductDescription": "Test Product",
"ItemQuantity": 1
}
]
},
"PaymentData": {
"PaymentMethods": [
{
"PaymentMethodType": "7",
"Amount": 100,
"Installments": 1,
"CardInfo": {
"Token": "{{token_from_generate}}",
"TokenProvider": "Tuna",
"SaveCard": false
},
"AuthenticationInformation": {
"Code": "my-random-auth-code-ORDER-001",
"ReferenceId": "{{referenceId_from_generate}}",
"TransactionId": "{{transactionId_from_generate}}"
}
}
],
"CountryCode": "BR",
"Amount": 100
},
"FrontData": {
"UserAgent": "Mozilla/5.0 ...",
"IpAddress": "203.0.113.10",
"AcceptHeader": "*/*",
"AcceptLanguage": "pt-BR",
"ColorDepth": "24",
"ScreenHeight": "864",
"ScreenWidth": "1536",
"TimeDifference": "-180",
"JavaEnabled": "N",
"JavaScriptEnabled": "Y"
}
}

See the full request/response examples (including a 3DS challenge response) in the Init API reference.

Payment method types 7 (3DS 2.0 Credit) and 8 (3DS 2.0 Debit) make the 3DS requirement explicit — see the payment methods reference table. Regular types 1/2 with authenticationInformation also carry the authentication data; your flow configuration in Tuna Console determines how it is used.

Step 5 — Render the challenge (frontend)#

If the Payment/Init response has methods[].status of P or 0 and a threeDSInfo object, the issuer demands a challenge. Your backend forwards threeDSInfo to the frontend, which renders the challenge inside an iframe by POSTing the token as a form field named JWT to threeDSInfo.url — this is the Cardinal Cruise step-up iframe flow.

The iframe size should follow the challengeWindowSize encoded in threeDSInfo.paRequest (a base64 JSON payload):

challengeWindowSizeiframe size (W × H)
01250 × 400
02390 × 400
03500 × 600
04600 × 400
05100% × 100% (fullscreen)

With tuna.js, call open3dsModal — it decodes paRequest, mounts a correctly sized modal with the challenge iframe, auto-submits the JWT form, and polls the payment status for you:

const response = /* Payment/Init response received from your backend */;
const method = response.methods[0];
if (["0", "P"].includes(method.status) && method.threeDSInfo) {
tuna.open3dsModal(
method.threeDSInfo,
method.methodId,
response.paymentKey,
(result) => {
if (result.paymentApproved) {
// Payment confirmed — finish the order
} else {
// Challenge failed or payment not approved
}
}
);
}

When you use checkoutAndPay (Mode 3), tuna.js detects the challenge and calls open3dsModal automatically — the callback receives was3DSChallengeTriggered: true and a 3dsPollingEnd window event fires when polling finishes.

Step 6 — Confirm the result (backend)#

After the challenge, Cardinal notifies Tuna and the payment resumes automatically. Confirm the final status by either:

If you use tuna.js's open3dsModal or checkoutAndPay, the polling is done for you.


Mode 1: 3DS with pure JS#

Your frontend handles card capture (using a custom form or any card entry UI) and runs all six steps manually, with your backend doing steps 1, 4, and 6.

How to use the Tuna sample form#

Open the Tuna-hosted sample for this mode:

👉 Pure JS sample form

  1. Enter the sessionId you obtained in Step 1.
  2. Fill in the card details (use a Cybersource test card — see test cards below).
  3. The form runs the 3DS device data collection and authentication challenge.
  4. On success it displays the token, code, referenceId, and transactionId.
  5. Copy those values into your Postman Init / Credit or Init / Debit request.

Follow steps 2–6 above using the Pure JS tabs.


Mode 2: 3DS using tuna.js for tokenization#

tuna.js handles card field rendering, tokenization (step 2), and device data collection (step 3) on the frontend. Your backend calls Payment/Init (step 4), and your frontend renders the challenge (step 5) with open3dsModal or a manual iframe.

How to use the Tuna sample form#

👉 tuna.js tokenization sample form

  1. Provide the sessionId from Step 1.
  2. tuna.js renders the card fields and handles tokenization + device data collection transparently.
  3. On completion it returns the authentication data you need for Payment/Init.
  4. Pass those values to your backend, which calls Payment/Init using the same request structure as step 4 above.

Integration outline#

Add tuna.js to your page:

<script src="https://js.tuna.uy/tuna-essentials.js"></script>

Initialize with the sessionId from your backend, tokenize, and run device data collection before handing off to your backend:

const tuna = Tuna("{{sessionId}}"); // add "sandbox" as 2nd argument for testing
// Render card fields with the pieces/forge API (see tuna.js docs), then:
const result = await tuna.checkout();
if (result.success) {
const { tokenData } = result;
const auth = tokenData.authenticationInformation;
if (auth && auth.accessToken && auth.deviceDataCollectionUrl) {
// Device data collection frame MUST run before Payment/Init
tuna.create3DSDataCollectionFrame(auth, (ready) => {
if (ready === true) {
// Send to your backend: tokenData.token, your code,
// auth.referenceId and auth.transactionId
yourBackend.initPayment({
token: tokenData.token,
code: "my-random-auth-code-ORDER-001",
referenceId: auth.referenceId,
transactionId: auth.transactionId,
});
}
});
}
}

When your backend returns the Init response, render the challenge if needed as shown in step 5. See the full tuna.js documentation for all configuration options.


Mode 3: 3DS using tuna.js for all interactions#

tuna.js handles the complete flow: card entry, device data collection, the Payment/Init call, the challenge modal, and status polling — all from the browser. Your backend only needs to create the session.

note

Because tuna.js calls Payment/Init from the frontend in this mode, the session must be created with the full order data (PaymentAccount, partneruniqueid, amount/items) — not just customer data.

How to use the Tuna sample form#

👉 tuna.js full-flow sample form

  1. Your backend creates a NewSession including the PaymentAccount and partneruniqueid.
  2. Return the sessionId to the frontend.
  3. tuna.js renders the checkout, performs 3DS, and submits the payment.
  4. Confirm the outcome via the callback, webhooks, or the Payment Status API.

Integration outline#

const tuna = Tuna("{{sessionId}}");
// Render card fields, then:
tuna.checkoutAndPay(
"creditCard",
totalAmount,
methodAmount,
(response) => {
if (response.success) {
if (response.was3DSChallengeTriggered) {
// tuna.js already opened the 3DS challenge modal and is polling.
window.addEventListener("3dsPollingEnd", (e) => {
if (e.detail.paymentApproved) {
// Payment confirmed
}
});
} else {
// Frictionless — check response.data for the payment result
}
}
}
);

For the Postman collection, this mode only requires the NewSession call — tuna.js takes over from there.


Mode 4: 3DS with manual tokenization#

Identical to Mode 1 in flow, but you build the card capture form yourself and call Token/Generate directly via JavaScript (step 2) without any Tuna sample UI. This gives you full control over the card capture experience while keeping sensitive card data off your backend.

  1. Create the session on your backend (step 1).
  2. Tokenize with the 3DS code from your own form (step 2).
  3. Run device data collection (step 3).
  4. Call Payment/Init from your backend (step 4).
  5. Render the challenge when threeDSInfo is returned (step 5).
  6. Confirm the result (step 6).

Providing browser/device data#

For all modes, passing frontData in Payment/Init is strongly recommended when using 3DS. It enables more accurate risk assessment and better frictionless rates:

"FrontData": {
"UserAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
"IpAddress": "203.0.113.10",
"AcceptHeader": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"AcceptLanguage": "pt-BR,pt;q=0.9,en-US;q=0.8",
"ColorDepth": "24",
"ScreenHeight": "864",
"ScreenWidth": "1536",
"TimeDifference": "-180",
"JavaEnabled": "N",
"JavaScriptEnabled": "Y"
}
FieldDescription
userAgentBrowser User-Agent header
ipAddressCardholder IP address
acceptHeaderHTTP Accept header
acceptLanguageBrowser language (IETF BCP47)
colorDepthScreen color depth in bits
screenHeight / screenWidthScreen dimensions in pixels
timeDifferenceUTC offset in minutes (e.g. -180 for BRT)
javaEnabled"Y" or "N"
javaScriptEnabled"Y" or "N"

Mobile apps (Android & iOS)#

Tuna's Android SDK and iOS SDK handle card tokenization natively (steps 1–2). For the 3DS challenge on mobile you have two options:

  1. WebView-based challenge — run steps 3 and 5 inside a WebView using the same iframe/form technique shown above. This works with the standard flow and requires no additional SDK.
  2. Native challenge with the Cardinal Mobile SDK — for a fully native challenge UI, integrate the Cardinal Mobile SDK (available for Android and iOS), which is Cybersource/Cardinal's official mobile challenge renderer. Contact your Tuna Account Manager to coordinate the credentials required for this setup.

In both cases the backend-side steps (1, 4, and 6) are identical to the web flow.


VTEX#

For VTEX merchants, 3DS is enabled out of the box. All you need to do is install Tuna's VTEX IO app:

tunabr.tuna-gateway

Install it from the VTEX App Store or via the VTEX IO CLI:

vtex install tunabr.tuna-gateway

After installation, follow the standard Tuna VTEX plugin setup to configure your Gateway Affiliation and credentials. There is no additional 3DS configuration required — Tuna handles authentication automatically based on your flow settings in Tuna Console.

Headless & mobile apps on VTEX

Tuna has partnerships with the leading headless and mobile implementors in the VTEX ecosystem. 3DS is fully supported in storefronts built by Compra Rápida, Trinio, and Kobe. If your storefront runs on one of these platforms, contact your implementor or your Tuna Account Manager to enable 3DS.


Tuna Checkout#

If you use Tuna Checkout — whether as a hosted payment link shared externally or embedded in your page via iframe — 3DS is supported out of the box with no additional integration work.

All you need is the flow configuration in Tuna Console (no-code flow editor) to enable 3DS for the relevant payment methods. Tuna Checkout will handle the full authentication challenge flow automatically, including device data collection and the redirect/embedded challenge UI.

If you need help setting up your flow to include 3DS, contact your Account Manager or the Tuna Support team.


Cybersource test cards#

Tuna's MPI runs on Cybersource/Cardinal Cruise. Use the test cards below in the sandbox environment. They come from Cybersource's official Payer Authentication test cases.

How to use test cards#

  • Replace every X in the card number with 0 (zero).
  • Use expiration month: January (01) and expiration year: current year + 3 (e.g., for 2026 use 01/2029).
  • Any CVV (e.g., 123) works in the sandbox.

Visa (Card Type = 001) — most common for Brazilian merchants#

Scenario3DS 2.2 Test CardEnroll resultValidation result
2.1 Frictionless — authentication successful4XXXXX XX XXXX 27X1 → 4000000000002701RC=100, VERes=Y, PARes=Y, ECI=05 (vbv)No challenge required
2.2 Frictionless — authentication unsuccessful4XXXXX XX XXXX 4574 → 4000000000004574RC=476, VERes=Y, PARes=N, ECI=07—
2.3 Stand-in — attempted4XXXXX XX XXXX 2719 → 4000000000002719RC=100, VERes=Y, PARes=A, ECI=06 (vbv_attempted)—
2.4 Frictionless — authentication unavailable4XXXXX XX XXXX 2313 → 4000000000002313RC=100, VERes=Y, PARes=U—
2.5 Frictionless — authentication rejected4XXXXX XX XXXX 2537 → 4000000000002537RC=476, VERes=Y, PARes=R—
2.6 Authentication not available (system error)4XXXXX XX XXXX 299X → 4000000000002990RC=100, VERes=U—
2.7 Check enrollment error4XXXXX XX XXXX 2446 → 4000000000002446RC=100, VERes=U—
2.8 Timeout4XXXXX XX XXXX 2354 → 4000000000002354RC=100, VERes=U—
2.9 Step-up — challenge successful4XXXXX XX XXXX 25X3 → 4000000000002503RC=475, VERes=Y, PARes=CRC=100, PARes=Y, ECI=05 (vbv)
2.10 Step-up — challenge unsuccessful4XXXXX XX XXXX 4293 → 4000000000004293RC=475, VERes=Y, PARes=CRC=476, PARes=N

Mastercard (Card Type = 002)#

Scenario3DS 2.2 Test CardEnroll result
2.1 Frictionless successful52XXXX XX XXX 2235 → 5200000000002235RC=100, VERes=Y, PARes=Y, ECI=02 (spa)
2.2 Frictionless unsuccessful52XXXX XX XXXX 2276 → 5200000000002276RC=476, VERes=Y, PARes=N
2.3 Stand-in attempted52XXXX XX XXXX 2482 → 5200000000002482RC=100, VERes=Y, PARes=A, ECI=01 (spa)
2.9 Step-up successful52XXXX XX XXXX 2151 → 5200000000002151RC=475, PARes=C; validation RC=100, ECI=02

Elo (Card Type = 054)#

Scenario3DS 2.2 Test CardEnroll resultValidation result
2.1 Frictionless — authentication successful65X529 XX XXXX 2XXX → 6505290000002000RC=100, VERes=Y, PARes=Y, ECI=05 (cs)No challenge required
2.2 Frictionless — authentication unsuccessful65X529 XX XXXX 2X18 → 6505290000002018RC=476, VERes=Y, PARes=N, ECI=07—
2.3 Stand-in — attempted65X529 XX XXXX 2026 → 6505290000002026RC=100, VERes=Y, PARes=A, ECI=06 (cs_attempted)—
2.4 Frictionless — authentication unavailable65X529 XX XXXX 2X34 → 6505290000002034RC=100, VERes=Y, PARes=U—
2.5 Frictionless — authentication rejected65X529 XX XXXX 2X83 → 6505290000002083RC=476, VERes=Y, PARes=R—
2.9 Step-up — challenge successful65X529 XX XXXX 219X → 6505290000002190RC=475, VERes=Y, PARes=CRC=100, PARes=Y, ECI=05 (cs)

ECI value reference#

The ECI (E-Commerce Indicator) value in the enrollment/validation response indicates the authentication outcome:

NetworkSuccessful auth ECIString valueAttempted ECIFailed ECI
Visa05vbv06 (vbv_attempted)07
Mastercard02spa0100
Amex05aesk06 (aesk_attempted)07
Elo05cs06 (cs_attempted)07
Discover05dipb06 (dipb_attempted)07

Interpreting test results#

PARes statusMeaningAction
YAuthentication successfulProceed with authorization — full liability shift
AAttempted (stand-in)Proceed with authorization — partial liability shift
UUnavailableProceed with authorization — no liability shift
NAuthentication failedDo not proceed; ask for another payment method
RAuthentication rejectedDo not proceed; ask for another payment method
CChallenge required (step-up)Wait for challenge completion before proceeding
Postman collection

Download the official collection at github.com/tuna-software/postman. The 3DS folder contains all four integration mode examples with pre-configured environments and test variables.


Cybersource & Cardinal documentation#

Cybersource is Tuna's 3DS provider. These external references are useful when you need the authoritative details of the underlying protocol:

ReferenceWhat it covers
Cybersource Payer Authentication (developer guide)The full payer-auth lifecycle: setup, device data collection, enrollment, validation
Device data collectionWhat the hidden iframe in step 3 does and why it matters
Payer Authentication testingOfficial test cases — source of the test cards above
Introduction to Payer AuthenticationCardinal Cruise concepts: browser-side integration, step-up, JWTs
Step-up iframeHow the challenge iframe works (the flow Tuna's integration is based on)
Cardinal Mobile SDK (Android/iOS)Native mobile challenge rendering for apps
Cybersource API referenceRaw Cybersource REST API documentation
note

You never call Cybersource/Cardinal APIs directly — Tuna does that for you. These links are provided so you can understand the underlying mechanics (JWTs, iframes, challenge window sizes) when debugging or customizing your challenge UI.


Related references#