Log in to the Smartpay Fuse Portal

1. Log in to the  Smartpay Fuse Portal (https://admin.smartpayfuse-test.barclaycard/ebc2) using the username and password you created for your sandbox account.

2. When prompted, set a new password for your Smartpay Fuse Portal account.

What to do next: Continue with Step 3: Create Flex Microform API Keys. 

Create Flex Microform API keys

A REST API key is required to authenticate REST-based requests on the Smartpay Fuse platform.

1. Choose Payment Configuration > Key Management from the left navigation menu. The Key Management page displays. The initial view displays keys that were previously created on the account. You can search for keys using the key type and the date range for which the key was created.
2. To generate a new key, select the Generate Key icon on the top right-hand side of the Key Management page.



A Create Key page displays, which provides a selection for different key types. For REST API integrations, select a key type from the REST APIs section on the page:



3. Choose one of these key types from the REST APIs section of the Create Key page::
   • Shared Secret: creates a key id and shared secret keypair used to sign HTTP requests.
   • Certificate: creates a PKCS12 certificate used for digitally signing API requests.
4. Scroll to the bottom of the Create Key page and click Generate Key. Your new keys are generated and displayed. Two keys are required for Flex Microform authentication:
   • A key id that is used to identify your new REST key in API requests.
   • A shared secret that is used to digitally sign API requests.



5. Copy and download the REST API keys.

Important: These REST keys must be stored securely in the Smartpay Fuse Portal. They allow API access to your service and must be treated as highly sensitive information. Adhere to API key management best practices to store and manage these keys.

If you click Generate another key, the Create Key page displays and allows you to generate new keys. Your keys have already been generated if this window displays. In this case, it is safe to click Cancel or navigate to other pages.

Continue with Step 4: Test the Integration using Flex Microforms.

Test Your Integration: Tokenize a Card Using Flex Microform

Before you begin:

• If you use the PHP sample application code, use version 5.6 or greater.
• Install the cURL, JSON, and APCU extensions.
• Create your test account (see Step 1: Create a Sandbox Account).
• Generate your API keys (see Step 2: Log In to the Smartpay Fuse Portal and Step 3: Create Flex Microform API Key.)

About this task: Successfully processing a test transaction confirms that your credentials are valid and your Flex Microform implementation is correct. You can use sample application code to test basic transactions. Sample application code is available in these languages:

• NodeJS
• DotNet
• PHP
• Java

These samples use the Smartpay Fuse brand because the Smartpay Fuse was created in partnership with Smartpay Fuse.

Each repository above will have README content associated, with instructions on how to deploy, configure, and run the examples.

Use the Microform sample code when implementing Hosted Fields. The sample code uses flexjs, which is a different integration approach. If you are interested in using the flexjs integration approach, please contact us.

The first step is to create the server-side request that generates the “capture context”. The capture context is a digitally signed JSON Web Token (JWT) that provides authentication and the one-time key required by the Flex Microform front-end.

1. Download the sample application code from GitHub.

2. Unpack the example code and check all file permissions.

3. Edit the file ExternalConfiguration.php and replace the apiKeyId, secretKey and merchantID default values with the values that are generated when you created your credentials in Step 3: Create Flex Microform API Keys.

   

4. Update currency used during transaction processing:
   a. Edit php-microform/paymentWithFlexTransientToken.php.
   b. Change the currency value to "GBP".

5. Upload the updated PHP sample code to your web server or run the code on localhost.
   If you plan to deploy the code somewhere other than http://localhost, set the value of the targetOrigins field to that location when you create the server side content.

6. Use composer to ensure dependencies are up to date (see README.md).

7. Deploy to your web server or run standalone (see README.md).

8. Navigate to the URL hosting the application to see the sample web page that includes the microform fields. For example, if you run the application on localhost, navigate to this URL: https://localhost:8000/checkout.php.
   
   

9. Use a test card number and associated information provided in our Testing Guides (https://developer.smartpayfuse.barclaycard/hello-world/testing-guide.html) to process a test transaction. Enter the information in the Checkout page and click Pay to process the transaction.

The sensitive card details are sent to Smartpay Fuse. Smartpay Fuse creates the token to safely pass through your system.

For this test, the token is returned and displays on the response page. You can proceed to Step 5: Test Integration Using a Tokenized Payment Card to use the token to perform a transaction, or choose the Make a Payment with Transient Token button to process a transaction.

In a live system, you will capture this token in the browser, return it to your back-office system, and continue the payment process using our REST API.

Continue with Step 5: Test Integration Using a Tokenized Payment Card.

Test Your Integration: Process a Payment Using the REST API

In Step 4: Test Integration using Flex Microforms, you successfully tokenized a payment card. You now have a transient token that can be safely passed through your back-end system and used to make a payment. Because this transient token represents a payment card rather than the card itself, it is safe to transmit this information through your system, only incurring SAQ A level PCI overheads.

To process a payment using the transient token, you need to use our REST API. This method allows you to progress and control the lifecycle state of a transaction from your back end system.

There may be additional steps that require further consumer and browser interactions, including fraud and Strong Customer configuration. These configurations can be complex flows to implement, so you might consider using our fully hosted payment page integration method. For more information, see the Secure Acceptance Hosted Checkout Quick Start Guide.

To process a payment using the transient token created in the previous step, use the standard ‘process payment’ REST message and replace the card details with the transient token JWT. For example:

{                                    
      "clientReferenceInformation": {
      "code": "TC50171_3"
   },
      "processingInformation": {
      "commerceIndicator": "internet"
   },
      "orderInformation": {
         "amountDetails": {
            "totalAmount": "22",
            "currency": "GBP"
         },
         "billTo": {
            "firstName": "John",
            "lastName": "Doe"
         }
      },
      "tokenInformation": {
         "transientTokenJwt": ""
      }
   }

You can also test this in the live console using the credentials you created in Step 3: Create Flex Micorofm API Keys and the token you generated in Step 4: Test Integration using Flex Microforms.

An introduction to the request builder is available here.

To demonstrate use of this tool, we will perform a simple sale transaction using the POST method on the /payments endpoint.

1. Open the Process a Payment page in the request builder.

   

2. Click the Configure tab at the top of the REST API Reference to configure the transaction you want to process::
   • URL: The target API URL. This is the destination endpoint of any API requests generated by the request builder.
   • Sample Request: The request type. This triggers the request builder to populate the request with appropriate fields.
   • Payment Processor Type: The Payment Processor. Select Barclays Merchant Services.

See the example below for the simple authentication transaction we will run in this example: 



In this example we will be performing a simple authorization of the card that you tokenised using the Microform; the card that is now represented by your “transient token” JWT.

3. Continue on to configure API credentials by scrolling further down in the “Configuration” tab to the Authentication section.

   Enter the credentials required to authenticate any request to Smartpay Fuse. Complete the below fields:

   • Merchant ID: Enter the Merchant ID generated during your account creation.
   • Key: Enter the REST API Key ID you created in Step 3: Create Flex Micorofm API Keys
   • Shared Secret Key: Enter the REST API Secret you created in Step 3: Create Flex Micorofm API Keys

    



4. Because the standard live console test is set-up to process a card number, you will need to modify the JSON payload in the “Request: Live Console” window. See the example below: 

{
      "clientReferenceInformation": {
         "code": "TC50171_3"
      },
      "orderInformation": {
         "amountDetails": {
            "totalAmount": "102.21",
            "currency": "GBP"
         },
         "billTo": {
            "firstName": "John",
            "lastName": "Doe",
            "address1": "1 Wokes Street",
            "locality": "Fleet",
            "postalCode": "GU51 WKS",
            "country": "GB",
            "email": "test@smartpayfuse.barclaycard",
            "phoneNumber": "4158880000"
         }
      },
      "tokenInformation": {
         "transientTokenJwt": "THE JWT RETURNED FROM YOUR MICROFORM     INTERACTIONT"
      }
   }

 

5. Click on the Send button to send the request to Smartpay Fuse.
   

See the below figure for a successful response. An unsuccessful response may occur if you did not enter a valid card expiration date or if you used different test data than those provided in the sandbox testing guide.



6. As a final step, log in to the Enterprise Business Centre and check that the transaction ran in the Transaction Management view:

    

   

Congratulations, you you have processed a transaction using a Flex Microform test application and the REST API through the online request builder.

For additional resources and guidance with integration, see the Further Information section.