Bill Payment

This API will use for bill payment

BillPayment

POST

Bill Payment

 

 

Description

 

This API will use for bill payment.

 

 

Version


V1


Resource URL

https://sandbox.jsbl.com/bill/v0 /payment


Header


Name Type Values Description Length

Authorization

String Bearer
Example: Bearer xxxxxxxxxxxxx
Access Token will be generated through OAuth API NA

Content-Type

String Example:
application/json
Only “application/json” Content-Type is supported. NA


Request Parameters

 

Name O/M Type Values Description Length

MobileNumber

M String 03124435484 Mobile Number  11

Amount

M String 100 Amount N/A

ProductId

M String LESCO001 Product Id 8

ConsumerNo

M String 1122 Consumer No 4
OtpPin M string asidu2ai3dj== One time Pin N/A

 

 

 

Sample  Request

 

{

                

                "MobileNumber":"03464991719",

                "Amount":"100",

                "ProductId":"LESCO001",

                "ConsumerNo":"1122",

                "OtpPin":"asidu2ai3dj=="

 

               

}

 

Response Parameters

 

Name Type Values Description Length

ResponseCode

String 00 Response Code 2

ResponseDescription

String Successful  Response Description N/A
TransactionCode String 1234567891234 Transaction id 13

 

 

 

 

 

 

Sample  Response

 

Success

{

                "ResponseCode":"00",

                "ResponseDescription":"Successful",

                "TransactionCode":"1234567891234"

                

}

 

 

Biller Company Information

 

Bill Code Bill Name

QUBEE001

Qubee Consumer Bill

QUBEE002

Qubee Distributor Bill
PTCL0010 PTCL Landline Bill

SSGC0001

SSGC Bill

SNGPL001

SNGPL Bill

LESCO001

LESCO Bill

HESCO001

HESCO Bill

GEPCO001

GEPCO Bill

IESCO

IESCO Bill

KESC0001

KESC Bill

MEPCO001

MEPCO Bill

FESCO

FESCO Bill
PESCO PESCO Bill

QESCO

QESCO Bill

TESCO001

TESCO Bill

SEPCO

SEPCO Bill

KWSB

KWSB Bill

LWASA

LWASA Bill

RWASA

RWASA Bill

MWASA

MWASA Bill

BWASA

BWASA Bill

FWASA

FWASA Bill
GWASA GWASA Bill

SCO

SCO Bill

CDGK

CDGK Bill

PTCL0015

Vfone Bill

WATEEN01

Wateen Internet Bill

WTRIBE01

WiTribe Bill

PTCL0011

PTCL EVO Prepaid Bill

PTCL0012

PTCL EVO Postpaid Bill
PTCL0013 PTCL Defaulter Bill

 

 

Response Code Details


{
"requestId": "3091741309081",
"errorCode": "01",
"errorMessage": "Bad Request - Invalid Authorization Header"
}



{
"requestId": "3091741309081",
"errorCode": "03",
"errorMessage": "Bad Request - Invalid Request Payload"
}



{
"requestId": "3091741309081",
"errorCode": "04",
"errorMessage": "Bad Request - Resource not found"
}



{
"requestId": "3091741309081",
"errorCode": "05",
"errorMessage": "Bad Request - Invalid Access Token"
}
{
    "ResponseCode": "00",
    "ResponseDescription": "Successful",
    "Rrn": "",
    "MobileNumber": "03464991719",
    "OtpPin": "3520214402765",
    
}


Try-out yourself

Header Parameters


Name Values Description
Authorization
(required)

Auth2.0 verification. "Bearer" keyword followed by a space and generated Access Token from OAuth API.Like "Bearer xxxxxxx"

Content-Type
(required)

Content Type applciation/json is supported

Body Parameters


Name Values Description
Request Body
(required)

Request Body

HTTP Basic

OAuth 2.0

API Key

Clear Request

Make a request and see the response.

Make a request and see the response.

Make a request and see the response.

Code examples

  • var request = require('request'),
    oauth_token = "YOUR_ACCESS_TOKEN",
    url = "https://sandbox.jsbl.com/bill/v0/payment"
    auth = "Bearer " + oauth_token;
    request(
    {
    method: 'POST'
    url : url,
    headers : {
    "Authorization" : auth
    }, json : {
    "MobileNumber" :"",
    "Amount" :"",
    "ProductId" :"",
    "ConsumerNo" :"",
    "OtpPin" :""
    
    } }, function (error, response, body) {
    // TODO: Use the body object to extract the response
    console.log(body)
    }
    )
    
  • <?PHP
    
    $url = 'https://sandbox.jsbl.com/bill/v0/payment';
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_HTTPHEADER, 
    array('Content-Type:application/json','Authorization:Bearer 
    ACCESS_TOKEN')); //setting custom header $curl_post_data = array(
    //Fill in the request parameters with valid values
    'MobileNumber' => ' ',
    'Amount' => ' ',
    'ProductId' => ' ',
    'ConsumerNo' => ' ',
    'OtpPin' => ' '
    
    ); $data_string = json_encode($curl_post_data);
    
  • require 'net/http'
    require 'net/https'
    require 'uri'
    uri = URI('https://sandbox.jsbl.com/bill/v0/payment')
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    request = Net::HTTP::Get.new(uri)
    request["accept"] = 'application/json'
    request["content-type"] = 'application/json'
    request["authorization"] = 'Bearer '
    request.body = "{
    \"MobileNumber\":\" \",
    \"Amount\":\" \",
    \"ProductId\":\" \",
    \"ConsumerNo\":\" \",
    \"OtpPin\":\" \"
    }"
    response = http.request(request)
    puts response.read_body
    
  • curl -X POST --header "Authorization: 
    Bearer " --header "Content-Type: 
    application/json" -d "{ \"MobileNumber\":\" \",
    \"Amount\":\" \",
    \"ProductId\":\" \",
    \"ConsumerNo\":\" \",
    \"OtpPin\":\" \"
    }" "https://sandbox.jsbl.com/bill/v0/payment"
    
  • OkHttpClient client = new OkHttpClient();
    MediaType mediaType = MediaType.parse("application/json");
    RequestBody body = RequestBody.create(mediaType, "{
    \"MobileNumber\":\" \",
    \"Amount\":\" \",
    \"ProductId\":\" \",
    \"ConsumerNo\":\" \",
    \"OtpPin\":\" \"
    
    }");
    Request request = new Request.Builder()
    .url("https://sandbox.jsbl.com/bill/v0/payment")
    .post(body)
    .addHeader("authorization", "Bearer YOUR_OAUTH_TOKEN")
    .addHeader("content-type", "application/json")
    .build();
    Response response = client.newCall(request).execute(); 
    

OTP Encryption

NOTE: To provide Unlimited Strength of encryption to your environment, Kindly download library, extract the zip file and replace these policy
file(local_policy &US_export_policy) on following location e-g: "java\jdk1.8.0_102\jre\lib\security"

Download Library
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.util.Arrays;

public class OTPEncryptionUtil {

        public static String encryptWithAES(String key, String strToEncrypt) {
            Security.addProvider(new BouncyCastleProvider());
            byte[] keyBytes = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
                    0x14, 0x15, 0x16, 0x17};
            try {
                keyBytes = generateKey(key);
                SecretKeySpec skey = new SecretKeySpec(keyBytes, "AES");
                byte[] input = strToEncrypt.trim().getBytes("UTF8");

                synchronized (Cipher.class) {
                    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
                    cipher.init(Cipher.ENCRYPT_MODE, skey);

                    byte[] cipherText = new byte[cipher.getOutputSize(input.length)];

                    int ctLength = cipher.update(input, 0, input.length, cipherText, 0);
                    ctLength += cipher.doFinal(cipherText, ctLength);

                    String encryptedString = new String(org.bouncycastle.util.encoders.Base64.encode(cipherText), "UTF8");
                    return encryptedString.trim();
                }
            } catch (UnsupportedEncodingException uee) {
                System.err.println("Crypto Exception:"+ uee);
            } catch (IllegalBlockSizeException ibse) {
                System.err.println("Crypto Exception:"+ ibse);
            } catch (BadPaddingException bpe) {
                System.err.println("Crypto Exception:"+ bpe);
            } catch (InvalidKeyException ike) {
                System.err.println("Crypto Exception:"+ ike);
            } catch (NoSuchPaddingException nspe) {
                System.err.println("Crypto Exception:"+ nspe);
            } catch (NoSuchAlgorithmException nsae) {
                System.err.println("Crypto Exception:"+ nsae);
            } catch (ShortBufferException e) {
                System.err.println("Crypto Exception:"+ e);
            }
            return null;
        }


        public static byte[] generateKey(String sKey) throws NoSuchAlgorithmException, UnsupportedEncodingException {
            final MessageDigest md = MessageDigest.getInstance("md5");
            final byte[] digestOfPassword = md.digest(sKey.getBytes("utf-8"));
            final byte[] keyBytes = Arrays.copyOf(digestOfPassword, 32);
            for (int j = 0, k = 16; j < 16; ) {
                keyBytes[k++] = keyBytes[j++];
            }
            return keyBytes;
        }

        public static void main(String[] args) {

            String key = new String("65412399991212FF65412399991212FF65412399991212FF");

            try {
                String pin="00000";
                String enpin=encryptWithAES(key,pin);
                System.out.println(enpin);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}

FAQs

You need to go through the section "How it Works".

Prerequisite(s)

1. OAuth2.0 Authorization Bearer access token

Resource Summary

Security

Authentication

Content Type

application/json

Working...