Judopay

https://docs.judopay.com/
Admin
Accept simple and secure payments in your app or website with Judopay’s SDKs. Quickly capture your...
Tokens:195,352
Snippets:2,343
Trust Score:8.8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Complete JudoConfiguration Example

Source: https://docs.judopay.com/react-native

A comprehensive example of JudoConfiguration, including imports and detailed setup for amount, reference (with consumer and payment references, and metadata), and judoId.

```typescript
import { JudoAmount, JudoReference, JudoConfiguration } from 'judokit-react-native'

const amount: JudoAmount = {
value: '1.00',
currency: 'GBP',
}
const reference: JudoReference = {
consumerReference: 'myConsumerReference',
paymentReference: 'myPaymentReference',
metadata: {
'metadatakey': 'metadataValue',
'metadatakey2': 'metadataValue',
}
}
const configuration: JudoConfiguration = {
judoId: 'my-judo-id',
amount: amount,
reference: reference,
}
```

--------------------------------

### Complete JudoPay Payment Integration Example

Source: https://docs.judopay.com/quick-start

This example demonstrates how to include the JudoPay Web SDK, configure the payment iFrame, and invoke a payment transaction. It includes setup for the payment form, error display, and handling success or error callbacks.

```javascript
<html>
<head>
    <!-- Include JudoPay WebSDK -->
    <script src="https://web.judopay.com/js/0.0/judopay.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
</head>
<body>

    <!-- Where the Judopay iFrame will be displayed -->
    <div id="payment-iframe" width="100%"></div>

    <!-- Payment button for submitting iFrame input -->
    <button id="submit-payment-button" onclick="handlePaymentButtonClick()"> Pay Now </button>

    <!-- Where the payment form errors will be shown -->
    <div class="judopay-errors" style="color:red"></div>

    <script>

        // Define config object for customizing style/behaviour of iFrame
        const iFrameConfiguration = {
            isGeoLocationGatheringAllowed: true,
            iframe: {
                language: "en",
                errorFieldId: 'judopay-errors',
                showCardTypeIcons: true,
                layout: "vertical",
                cardTypeIconRight: "10px",
                cardTypeIconTop: "-2px",
                backgroundColor: "#FFFFFF",
                enabledPaymentMethods: ['CARD'],
                defaultCountryCode: 'UK',
                isCountryAndPostcodeVisible: false,
                isCardHolderNameVisible: true,
                errorsDisplay: "HIDE_UNDER_FIELDS",
                disableUnderline: false,
                shouldAutofocus: true,
            }
        }

        // Initializing/creating an instance of the Judopay webSDK
        var judo = new JudoPay("yourAPIToken", true);

        // Displaying the card entry iFrame
        var payment = judo.createCardDetails("payment-iframe", iFrameConfiguration);

        //Define config object for payment/preauth
        const paymentConfiguration = {
            judoId: "yourJudoId",
            amount: 1.01,
            currency: "GBP",
            phoneCountryCode: "44",
            challengeRequestIndicator: "challengeAsMandate",
            initialRecurringPayment: false,
            yourConsumerReference: "yourConsumerReference",
            yourPaymentReference: "yourPaymentReference",
            billingAddress: {
                address1: "My house",
                address2: "My street",
                town: "My town",
                postCode: "TR14 8PA",
                country: "826"
            },
            mobileNumber: "07999999999",
            emailAddress: "contact@judopay.com"
        }

        function handleSuccess(response) {
            //Redirect to success page and handle response
        }
        function handleError(error) {
            //Redirect to error page and handle error
        }

        //Called when payment button pressed to invoke payment
        function handlePaymentButtonClick() {
            judo.invokePayment("yourPaymentSession", paymentConfiguration)
                .then(handleSuccess)
                .catch(handleError)
        }
    </script>

</body>
</html>
```

--------------------------------

### Payment Configuration Object Example

Source: https://docs.judopay.com/quick-start

Defines the necessary details for initiating a payment or pre-authorization. Ensure these details align with your payment session setup.

```javascript
const paymentConfiguration = {
    judoId: "yourJudoId",
    amount: 1.01,
    currency: "GBP",
    phoneCountryCode: "44",
    challengeRequestIndicator: "challengeAsMandate",
    initialRecurringPayment: false,
    yourConsumerReference: "yourConsumerReference",
    yourPaymentReference: "yourPaymentReference",
    billingAddress: {
        address1: "My house",
        address2: "My street",
        town: "My town",
        postCode: "TR14 8PA",
        country: "826"
    },
    mobileNumber: "07999999999",
    emailAddress: "contact@judopay.com",
    primaryAccountDetails: {
        name: "Doe",
        accountNumber: "9999999",
        dateOfBirth: "1989-09-19",
        postCode: "AB1 2CD"
    }
}
```

--------------------------------

### Install JudoPay.Net Package

Source: https://docs.judopay.com/net-and-php-integrations

Use this command in the Package Manager Console to install the JudoPay.Net NuGet package.

```powershell
install-Package JudoPay.Net
```

--------------------------------

### Example package.json with Judopay SDK

Source: https://docs.judopay.com/react-native

This is an example of how the judo-react-native dependency should appear in your package.json file.

```json
{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    ...
  },
  "dependencies": {
    "judo-react-native": "4.0.0",
    ...
  },
  "devDependencies": {
    ...
  },
  ...
}
```

--------------------------------

### Example of a Complete Custom JudoTheme

Source: https://docs.judopay.com/react-native

An example demonstrating how to create a complete custom theme by overriding specific properties of JudoTheme. This theme can then be applied to the UI configuration.

```typescript
const myTheme: JudoTheme = {
largeTitleFont: 'Avenir',
largeTitleSize: 20,
buttonColor: '#FFFFFF',
buttonCornerRadius: 4.0,
backButtonImage: 'my-custom-icon-filename'
}

const uiConfiguration: JudoUIConfiguration {
...,
theme: myTheme,
...,
}

const configuration: JudoConfiguration = {
...,
uiConfiguration: uiConfiguration,
…
}
```

--------------------------------

### Start JudoActivity with JudoConfiguration

Source: https://docs.judopay.com/deprecated-integration-methods

Launch the JudoActivity using an Intent, passing the configured Judo object. This starts the payment flow with PayByBankApp enabled as a payment method.

```kotlin
//Start JudoActivity with the JudoConfiguration object:

val intent = Intent(this, JudoActivity::class.java)
intent.putExtra(JUDO_OPTIONS, judo)
startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
```

--------------------------------

### Web Payments Request Example

Source: https://docs.judopay.com/testing-web-payments-card-payments

This example demonstrates how to configure various parameters for a Web Payments card transaction request.

```APIDOC
## Web Payments Card Payments

### Description
This section details the parameters that can be sent in a Web Payments card payment request to customize the user experience and transaction behavior.

### Method
POST (Assumed based on context of sending payment details)

### Endpoint
/websites/judopay (Assumed based on project path)

### Parameters
#### Request Body
- **successUrl** (String) - Optional - The URL to which the consumer is redirected if their transaction is successful. If not set, the default success URL specified on your account is used. Maximum length 2048 characters.
- **cancelUrl** (String) - Optional - The URL to which the consumer is redirected if they cancel the transaction or if the transaction fails. If not set, the default cancel URL specified on your account is used. Maximum length 2048 characters.
- **hideBillingInfo** (Boolean) - Optional - This flag can be used to determine whether the 'Billing information' page is shown on the Webpayments UI. Default = true.
- **hideReviewInfo** (Boolean) - Optional - This flag can be used to determine whether the 'Review and Confirm' page is shown on the Webpayments UI. Default = true.
- **threeDSecure** (Object) - Optional - Configuration for 3D Secure authentication.
  - **challengeRequestIndicator** (String) - Indicates the type of challenge request. Values: `noPreference`, `noChallenge`, `challengePreferred`, `challengeAsMandate`.
  - **scaExemption** (String) - To apply for an exemption from SCA. Values: `lowValue`, `trustedBeneficiary`, `transactionRiskAnalysis`.

### Request Example
```json
{
  "successUrl": "https://your.success.url",
  "cancelUrl": "https://your.cancel.url",
  "hideBillingInfo": false,
  "hideReviewInfo": false,
  "threeDSecure": {
    "challengeRequestIndicator": "challengePreferred",
    "scaExemption": "lowValue"
  }
}
```

### Response
(Response details not provided in the source text)
```

--------------------------------

### Process Deep Link URL and Start JudoActivity

Source: https://docs.judopay.com/deprecated-integration-methods

This function checks for a deep link URI, constructs a new PBBAConfiguration with the deep link URL, builds a Judo object, and starts the JudoActivity for payment processing.

```kotlin
private fun checkForDeepLink(intent: Intent? = this.intent) {
 val uri = intent?.data
 val newIntent = Intent(this, JudoActivity::class.java)
 if (uri.contains("your://scheme")) {  
 val newPbbaConfig = pbbaConfiguration.newBuilder()
 .setDeepLinkURL(uri)
 .build()
 val judo = getJudo(PaymentWidgetType.PAY_BY_BANK_APP).newBuilder()
 .setPBBAConfiguration(newPbbaConfig)
 .build()
newIntent.putExtra(JUDO_OPTIONS, judo)
 startActivityForResult(newIntent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
 }
 }
```

--------------------------------

### Google Pay Request Example

Source: https://docs.judopay.com/testing-digital-wallet-payments-via-api

This is an example of a request body for initiating a Google Pay payment through the Judopay API. It includes Google Pay wallet details, judoId, consumer and payment references, amount, currency, and optional metadata.

```APIDOC
## Google Pay Request Example

### Description
This is an example of a request body for initiating a Google Pay payment through the Judopay API. It includes Google Pay wallet details, judoId, consumer and payment references, amount, currency, and optional metadata.

### Request Example
```json
{
  "googlePayWallet": {
    "cardNetwork": "VISA",
    "cardDetails": "1234",
    "token": "{\"signature\":\"xxx\",\"protocolVersion\":\"ECv1\",\"signedMessage\":\"{\\\"encryptedMessage\\\":\\\"xxx\\\",\\\"ephemeralPublicKey\\\":\\\"xxx\\\",\\\"tag\\\":\\\"xxx\\\"}\"}"
  },
  "judoId": 100100100,
  "yourConsumerReference": "2b45fd3f-cee5-4e7e-874f-28051db65408",
  "yourPaymentReference": "6482c678-cad3-4efd-b081-aeae7a89a134",
  "amount": 1.01,
  "currency": "GBP",
  "yourPaymentMetaData": {
    "internalLocationRef": "Example",
    "internalId": 99
  }
}
```
```

--------------------------------

### PHP Server SDK Setup (Sandbox)

Source: https://docs.judopay.com/deprecated-integration-methods

Instantiate the JudoPaymentsFactory for the sandbox environment using your API token and secret.

```php
var client = JudoPaymentsFactory.Create(
 JudoEnvironment.Sandbox,
  <yourApiToken>,
 <yourApiSecret> 
);
```

--------------------------------

### GET Transaction Result Example

Source: https://docs.judopay.com/web-payments

Retrieve detailed transaction receipt information by sending a GET request to the Judopay API with a transaction reference. This response includes status, amount, currency, and card details.

```json
//You will receive the following transaction receipt information:
"status": "Success",
    "shortReference": "kyldmO",
    "amount": 399,
    "companyName": "My Company",
    "currency": "GBP",
    "expiryDate": "2030-12-07T18:28:32.8596+00:00",
    "judoId": "100013531",
    "paymentCancelUrl": "https://judopay.com",
    "paymentSuccessUrl": "https://judopay.com",
    "reference": "6QcAAAcAAAACAAAACwAAAIgf-PCUS9UPbuk",
    "allowedCardTypes": [
        1,
        2,
        3,
        8,
        10,
        11,
        12,
        13
    ],
    "response": {
        "postUrl": "https://pay-sandbox.judopay.com/v2",
        "reference": "6QcAAAcAAAACAAAACwAAAIgf-PCUS9UPbuk"
    },
    "transactionType": "Payment",
    "yourConsumerReference": "tk-test-2025-07-02",
    "yourPaymentReference": "tk-test-2025-07-02-05",
    "webPaymentOperation": 0,
    "isJudoAccept": false,
    "isThreeDSecureTwo": true,
    "noOfAuthAttempts": 1,
    "receipt": {
        "receiptId": "1257662426096709632",
        "yourPaymentReference": "tk-test-2025-07-02-05",
        "type": "Payment",
        "createdAt": "2025-07-02T12:41:28.6095+01:00",
        "result": "Success",
        "message": "AuthCode: 321116",
        "judoId": 100013531,
        "merchantName": "John Doe",
        "appearsOnStatementAs": "APL*/JohnDoe         ",
        "netAmount": "399.00",
        "amount": "399.00",
        "currency": "GBP",
        "acquirerTransactionId": "74450001183715833468",
        "externalBankResponseCode": "",
        "authCode": "321116",
        "postCodeCheckResult": "Unknown",
        "acquirer": "Cashflows",
        "webPaymentReference": "6QcAAAcAAAACAAAACwAAAIg",
        "noOfAuthAttempts": 1,
        "cardDetails": {
            "cardLastfour": "3436",
            "endDate": "1230",
            "cardToken": "SOF-OKNnyt-4RA-pCpKtsQabeg",
            "cardType": 11,
            "cardScheme": "VISA",
            "cardFunding": "Debit",
            "cardCategory": "",
            "cardCountry": "FR",
            "bank": "CREDIT INDUSTRIEL ET COMMERCIAL",
            "cardHolderName": "Challenge Required"
        },
        "billingAddress": {},
        "consumer": {
            "yourConsumerReference": "tk-test-2025-07-02"
        },
        "yourPaymentMetaData": {
            "customerEmail": "john.doe@judopay.com",
            "policy_id": "policy001",
            "country_origin": "PL"
        },
        "threeDSecure": {
            "attempted": true,
            "result": "PASSED",
            "challengeRequestIndicator": "ChallengeAsMandate",
            "eci": "05"
        },
        "risks": {
            "postCodeCheck": "UNKNOWN",
            "cv2Check": "PASSED",
            "eciIndicator": "05",
            "merchantSuggestion": "Allow"
        }
    }
}

```

--------------------------------

### Get Transactions with Specific Page Size

Source: https://docs.judopay.com/testing-get-transactions

Retrieve a list of transactions with a specified number of results per page. The 'pageSize' field can be set between 1 and 500, with a default of 10. This example requests 20 transactions.

```api
GET /transactions?pageSize=20
```

--------------------------------

### Configure JudoPay Client for Live Environment (.NET)

Source: https://docs.judopay.com/net-and-php-integrations

Replace the sandbox environment setting with JudoEnvironment.Live and provide your live API credentials.

```apex
//In the:
JudoPaymentsFactory.Create

//method, change the environment from Sandbox to Live:
var client = JudoPaymentsFactory.Create(JudoEnvironment.Live, "YOUR_API_TOKEN", "YOUR_API_SECRET");

```

--------------------------------

### Example cardAddress Block

Source: https://docs.judopay.com/testing-card-payments

An example of the cardAddress block structure required for payment requests including billing address information.

```json
"cardAddress": {
    "address1": "CardHolder House",
    "address2": "1 CardHolder Street",

    "town": "CardHolder Town",
    "postCode": "AB1 2CD",
    "countryCode": 826,
    "state": "FL"
}
```

--------------------------------

### Initialize JudoPay SDK

Source: https://docs.judopay.com/quick-start

Create an instance of the JudoPay Web SDK. Replace 'yourAPIToken' with your actual API Token. Set the second parameter 'useSandbox' to true for the Sandbox environment or false for Production.

```javascript
var judo = new JudoPay("yourAPIToken", true); //initialize library
```

--------------------------------

### Initialize Judo with Google Pay Configuration

Source: https://docs.judopay.com/android

Configure and build the Judo SDK instance for pre-auth Google Pay transactions. Ensure Google Pay configuration is set before building.

```kotlin
val judo = Judo.Builder(PaymentWidgetType.PRE_AUTH_GOOGLE_PAY)
    ...
    .setGooglePayConfiguration(googlePayConfiguration)
    .build()
```

--------------------------------

### Example cardAddress Block

Source: https://docs.judopay.com/testing-checkcard

This is an example of the cardAddress block used in a checkCard request. Ensure the countryCode is in ISO 3166-1 format.

```json
{
"cardAddress": {
"address1": "CardHolder House",
"address2": "1 CardHolder Street",
"town": "CardHolder Town",
"postCode": "AB1 2CD",
"countryCode": 826,
"state": "FL"
}
}
```

--------------------------------

### PHP Server SDK Initialization

Source: https://docs.judopay.com/deprecated-integration-methods

Initialize the Judopay object with API credentials and environment configuration. Set 'useProduction' to false for sandbox.

```php
$judopay = new \Judopay(
 array(
 'apiToken' => 'your-token',
 'apiSecret' => 'your-secret',
 'judoId' => 'your-judo-id',
 //Set to true on production, defaults to false which is the sandbox
 'useProduction' => false
 )
);
```

--------------------------------

### Void Response Example

Source: https://docs.judopay.com/testing-voids

This is an example of a successful response from the JudoPay API after a void transaction. It includes details of the voided transaction and its status.

```json
{
    "receiptId": "914571470754189312",
    "originalReceiptId": "914571434016280576",
    "yourPaymentReference": "e61b5555-31fe-41f3-843a-905a28c552f0",
    "type": "VOID",
    "createdAt": "2022-11-28T17:40:31.4741+00:00",
    "result": "Success",
    "message": "Void successful",
    "judoId": 100502814,
    "merchantName": "Shodan - Cybersource Routing",
    "appearsOnStatementAs": "APL*/ShodanCybersourceRo",
    "originalAmount": "5.00",
    "amountCollected": "0.00",
    "netAmount": "5.00",
    "amount": "5.00",
    "currency": "GBP",
    "externalBankResponseCode": "",
    "cardDetails": {
        "cardLastfour": "1111",
        "endDate": "1230",
        "cardToken": "EndpeR5KPgLAweDhdj3lzKj5ZEcqpr4s",
        "cardType": 1,
        "cardScheme": "VISA",
        "cardFunding": "Credit",
        "cardCategory": "",
        "cardCountry": "US",
        "bank": "JPMORGAN CHASE BANK, N.A."
    },
    "consumer": {
        "yourConsumerReference": "CardsWithMultipleConsumers2"
    }
}
```

--------------------------------

### Check for Installed Banking Apps

Source: https://docs.judopay.com/deprecated-integration-methods

Before displaying the PayByBankApp button, check if any compatible banking apps are installed on the device using JudoKit.isBankingAppAvailable().

```swift
if (JudoKit.isBankingAppAvailable()) {
  // Add the PBBA button
}
```

--------------------------------

### Import Judopay Web SDK and Create Instance

Source: https://docs.judopay.com/adding-the-payment-iframe-to-your-web-page-tutorial

Include the Judopay Web SDK script in your HTML head and create an instance of the JudoPay object in your JavaScript. Set the second argument to true for the test environment.

```javascript
//in your HTML <head> element:
<script src="https://web.judopay.com/js/0.0/judopay.min.js"></script>
//in a HTML <script> tag or JavaScript file:
var judo = new JudoPay("yourAPIToken", true) 
//where true uses the test environment
```

--------------------------------

### Launch Judo Payment Flow

Source: https://docs.judopay.com/android

Initiate the Judo payment activity by passing the configured Judo options via an Intent. This is used after building the Judo instance.

```kotlin
val intent = Intent(this, JudoActivity::class.java);
intent.putExtra(JUDO_OPTIONS, judo);
startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE);
```

--------------------------------

### Payment Response Example

Source: https://docs.judopay.com/testing-digital-wallet-payments-via-api

This is an example of a successful response received after initiating a payment, detailing transaction information, card details, and consumer references.

```APIDOC
## Payment Response Example

### Description
This is an example of a successful response received after initiating a payment, detailing transaction information, card details, and consumer references.

### Response Example
```json
{
    "receiptId": "914568453493526528",
    "yourPaymentReference": "34a73594-f3b2-414c-a5c9-58679530b418",
    "type": "Payment",
    "result": "Success",
    "judoId": 100502814,
    "originalAmount": "5.00",
    "netAmount": "5.00",
    "amount": "5.00",
    "currency": "GBP",
    "cardDetails": {
        "cardLastfour": "1111",
        "endDate": "1230",
        "cardToken": "SOF-xFmZmEnoR_Sj9mtrCvrxhw",
        "cardType": 1,
        "cardScheme": "VISA",
        "cardFunding": "Credit",
        "cardCategory": "",
        "cardCountry": "US",
        "bank": "JPMORGAN CHASE BANK, N.A."
    },
    "cardAddress": {
    "address1": "CardHolder House",
    "address2": "1 CardHolder Street",
    "town": "CardHolder Town",
    "postCode": "AB1 2CD",
    "countryCode": 826
    },
    "consumer": {
        "yourConsumerReference": "2b45fd3f-cee5-4e7e-874f-28051db65408"
    }
   }
```
```

--------------------------------

### Token Details Modal Style Object Example

Source: https://docs.judopay.com/token-payment-request

An example of the tokenDetailsModalStyle object that can be passed to `invokeTokenPayment` or `invokeTokenPreauth` to customize the appearance of the token details modal.

```APIDOC
## Token Details Modal Style Object Example

### Description
This object allows for customization of the Token Details Modal's appearance, including labels, placeholders, and overall styling.

### Style Object Structure
*   `labelTextContent` (String) - Style for the security code label.
*   `inputPlaceholder` (String) - Style for the security code input placeholder.
*   `labelTextContent2` (String) - Style for the cardholder name label.
*   `inputPlaceholder2` (String) - Style for the cardholder name input placeholder.
*   `buttonTextContent` (String) - Text content for the submit button.
*   `style` (Object) - An object containing CSS properties for various modal elements:
    *   `form` (Object) - Styles for the form container.
    *   `field` (Object) - Styles for input fields.
    *   `label` (Object) - Styles for labels.
    *   `button` (Object) - Styles for the submit button.

### Example
```javascript
const tokenDetailsModalStyle = {
    labelTextContent: 'Security code',
    inputPlaceholder: 'Type your code here',
    labelTextContent2: 'Cardholder name',
    inputPlaceholder2: 'Type your name here',
    buttonTextContent: 'Submit',
    style: {
        form: {
            padding: '20px 16px',
            maxWidth: '300px',
            margin: 'auto',
            width: '80%',
            borderRadius: '4px'
        },
        field: {
            width: '100%',
            padding: '8px',
            color: '#999999'
        },
        label: {
            width: '100%',
            padding: '8px 0px 8px 0px',
            color: '#999999'
        },
        button: {
            backgroundColor: '#222',
            borderRadius: '4px',
            borderStyle: 'none',
        }
    }
}
```
```

--------------------------------

### Network Error Message Example

Source: https://docs.judopay.com/troubleshooting

This is an example of a network error message that might be returned by the Web SDK. It indicates a general network connectivity issue.

```json
{
  "name":"Error",
  "message":"Network Error"
}
```

--------------------------------

### Configure Sandbox Client with Token and Secret

Source: https://docs.judopay.com/net-and-php-integrations

Instantiate the JudoPaymentsFactory for the sandbox environment using your API token and secret. Ensure you are using sandbox-specific credentials.

```csharp
var client = JudoPaymentsFactory.Create(
 JudoEnvironment.Sandbox,
  <yourApiToken>,
 <yourApiSecret>
);
```

--------------------------------

### JudoPay Receipt Object Example

Source: https://docs.judopay.com/testing-digital-wallet-payments-via-web-sdk

This is an example of a successful payment response object returned by the JudoPay SDK, containing details about the transaction and card used.

```json
{
    "receiptId": "914568453493526528",
    "yourPaymentReference": "34a73594-f3b2-414c-a5c9-58679530b418",
    "type": "Payment",
    "result": "Success",
    "judoId": 100502814,
    "originalAmount": "5.00",
    "netAmount": "5.00",
    "amount": "5.00",
    "currency": "GBP",
    "cardDetails": {
        "cardLastfour": "1111",
        "endDate": "1230",
        "cardToken": "SOF-xFmZmEnoR_Sj9mtrCvrxhw",
        "cardType": 1,
        "cardScheme": "VISA",
        "cardFunding": "Credit",
        "cardCategory": "",
        "cardCountry": "US",
        "bank": "JPMORGAN CHASE BANK, N.A."
    },
    "cardAddress": {
    "address1": "CardHolder House",
    "address2": "1 CardHolder Street",
    "town": "CardHolder Town",
    "postCode": "AB1 2CD",
    "countryCode": 826
    },
    "consumer": {
        "yourConsumerReference": "2b45fd3f-cee5-4e7e-874f-28051db65408",
    },
   }
```

--------------------------------

### Import and Initialize Judopay SDK with Token and Secret

Source: https://docs.judopay.com/react-native

Import the JudoPay class and initialize it with your Judopay token and secret.

```javascript
import JudoPay from 'judokit-react-native'
const judoPay = new JudoPay({token: "my-token", secret: "my-secret"})
```

--------------------------------

### Configure Judo for Live Environment

Source: https://docs.judopay.com/deprecated-integration-methods

Switch your Judo instance to the live environment by changing the Environment property and replacing sandbox API tokens and secrets with your live credentials.

```csharp
Environment = JudoEnvironment.Live,
ApiToken = "<API_TOKEN>",
ApiSecret = "<API_SECRET>",

```

--------------------------------

### Install Judopay React Native SDK

Source: https://docs.judopay.com/react-native

Add the Judopay React Native SDK to your project using npm or yarn.

```bash
npm install judokit-react-native
yarn add judokit-react-native
```

--------------------------------

### Response Example for Receipt ID

Source: https://docs.judopay.com/testing-get-transactions

This is an example of the JSON response when retrieving a single transaction by its receipt ID. It includes all relevant details about the transaction, card, and consumer.

```JSON
{
    "receiptId": "968893796475637760",
    "yourPaymentReference": "Payment111",
    "type": "Payment",
    "createdAt": "2023-04-27T16:18:02.3780+01:00",
    "result": "Success",
    "message": "AuthCode: 033670",
    "judoId": 100042597,
    "merchantName": "Shodan",
    "appearsOnStatementAs": "Shodan",
    "netAmount": "5.00",
    "amount": "5.00",
    "currency": "GBP",
    "acquirerTransactionId": "75516047204453281723",
    "externalBankResponseCode": "",
    "authCode": "033670",
    "postCodeCheckResult": "Unknown",
    "acquirer": "Barclays",
    "cardDetails": {
        "cardLastfour": "3436",
        "endDate": "1230",
        "cardToken": "SOF-u-CNJ8D3TSmz70eeCeZ_2g",
        "cardType": 11,
        "cardScheme": "VISA",
        "cardFunding": "Debit",
        "cardCategory": "",
        "cardCountry": "FR",
        "bank": "CREDIT INDUSTRIEL ET COMMERCIAL",
        "cardHolderName": "Emma Waters"
    },
    "billingAddress": {},
    "consumer": {
        "yourConsumerReference": "Alayna.Crona@example.net"
    },
    "yourPaymentMetaData": {},
    "threeDSecure": {
        "attempted": false
    },
    "risks": {
        "postCodeCheck": "UNKNOWN",
        "cv2Check": "PASSED",
        "merchantSuggestion": "Allow"
    }
}
```

--------------------------------

### Configure and Initialize Google Pay Button

Source: https://docs.judopay.com/testing-digital-wallet-payments-via-web-sdk

This example demonstrates how to configure the Google Pay payment request object, including merchant information, allowed payment methods, and transaction details, and then initialize the Google Pay button.

```javascript
const googlePayConfiguration = {
    judoId: "yourJudoId",
    amount: "12.99",
    currency: "GBP",
    yourPaymentReference: "yourPaymentReferenc",
    yourConsumerReference: "yourConsumerReference",
    paymentSession: "yourPaymentSession",
    environment: "TEST",
    transactionMode: "payment",
    buttonStyle: {
        type: "buy",
        sizeMode: "static",
        locale: "en",
        width: "200",
        height: "36"
  	} 
    paymentRequest = {
      merchantInfo: {
          merchantId: 'yourMerchantId' //issued after registration
      },
      allowedPaymentMethods: [{
          parameters: {
              allowedCardNetworks: ['VISA', 'MASTERCARD', 'AMEX']
          }
      }],
      transactionInfo: {
          totalPriceStatus: 'FINAL',
          totalPrice: '1.0',
          currencyCode: 'GBP',
          countryCode: 'GB'
      }    
}
    onSuccess: handleSuccess, // Judopay receipt object will be returned
    onError: handleError // Judopay error object will be returned
}

//1. initialize Google Pay button with Google Pay configuration object (includes logic to trigger the payment when clicked)
const button = judo.digitalWallets.getGooglePayButton(googlePayConfiguration)

//2. add the Google Pay Button to your page:
const container = document.getElementById('google-pay-button-container')
container.append(button)
```

--------------------------------

### Refund Request Example

Source: https://docs.judopay.com/testing-refunds

This example demonstrates how to construct a refund request. Ensure you have the correct receiptId for the original transaction. The amount, currency, and yourPaymentReference are required fields.

```json
{
  "amount": "25.00",
  "currency": "GBP",
  "yourPaymentReference": "test-refund-123"
}
```

--------------------------------

### Initialize JudoKit with Basic Authorization

Source: https://docs.judopay.com/deprecated-integration-methods

Initialize the JudoKit SDK using basic authorization with your Judo token and secret. Set isSandboxed to true for testing.

```swift
let authorization: JPAuthorization = JPBasicAuthorization(token: JUDO_TOKEN,
 andSecret: JUDO_SECRET)
judoKit = JudoKit(authorization: authorization)
judoKit.isSandboxed = true
```
Tokens:
Raw