BIIN LOOKUP API
_{MobiBiin by MobiCard}

#!/bin/bash

# Configuration
MOBICARD_VERSION="2.0"
MOBICARD_MODE="LIVE"
MOBICARD_MERCHANT_ID="4"
MOBICARD_API_KEY="YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9"
MOBICARD_SECRET_KEY="NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
MOBICARD_TOKEN_ID=$(shuf -i 1000000-1000000000 -n 1)
MOBICARD_TXN_REFERENCE=$(shuf -i 1000000-1000000000 -n 1)
MOBICARD_SERVICE_ID="20000"
MOBICARD_SERVICE_TYPE="BIINLOOKUP"

# Accepts 6-digit BIN, 8-digit BIIN, or full card number
MOBICARD_CARD_NUMBER="5173350006475601"
MOBICARD_CARD_BIIN=${MOBICARD_CARD_NUMBER:0:8} # Extract first 8 digits

# Create JWT Header
JWT_HEADER=$(echo -n '{"typ":"JWT","alg":"HS256"}' | base64 | tr '+/' '-_' | tr -d '=')

# Create JWT Payload
PAYLOAD_JSON=$(cat << EOF
{
  "mobicard_version": "$MOBICARD_VERSION",
  "mobicard_mode": "$MOBICARD_MODE",
  "mobicard_merchant_id": "$MOBICARD_MERCHANT_ID",
  "mobicard_api_key": "$MOBICARD_API_KEY",
  "mobicard_service_id": "$MOBICARD_SERVICE_ID",
  "mobicard_service_type": "$MOBICARD_SERVICE_TYPE",
  "mobicard_token_id": "$MOBICARD_TOKEN_ID",
  "mobicard_txn_reference": "$MOBICARD_TXN_REFERENCE",
  "mobicard_card_biin": "$MOBICARD_CARD_BIIN"
}
EOF
)

JWT_PAYLOAD=$(echo -n "$PAYLOAD_JSON" | base64 | tr '+/' '-_' | tr -d '=')

# Generate Signature
HEADER_PAYLOAD="$JWT_HEADER.$JWT_PAYLOAD"
JWT_SIGNATURE=$(echo -n "$HEADER_PAYLOAD" | openssl dgst -sha256 -hmac "$MOBICARD_SECRET_KEY" -binary | base64 | tr '+/' '-_' | tr -d '=')

# Create Final JWT
MOBICARD_AUTH_JWT="$JWT_HEADER.$JWT_PAYLOAD.$JWT_SIGNATURE"

# Make API Call
API_URL="https://mobicardsystems.com/api/v1/biin_lookup"

RESPONSE=$(curl -X POST "$API_URL" \
  -H "Content-Type: application/json" \
  -d "{\"mobicard_auth_jwt\":\"$MOBICARD_AUTH_JWT\"}" \
  --silent)

echo "$RESPONSE" | python -m json.tool

import json
import base64
import hmac
import hashlib
import random
import requests

class MobicardBiinLookup:
    def __init__(self, merchant_id, api_key, secret_key):
        self.mobicard_version = "2.0"
        self.mobicard_mode = "LIVE"
        self.mobicard_merchant_id = merchant_id
        self.mobicard_api_key = api_key
        self.mobicard_secret_key = secret_key
        self.mobicard_service_id = "20000"
        self.mobicard_service_type = "BIINLOOKUP"
        
        self.mobicard_token_id = str(random.randint(1000000, 1000000000))
        self.mobicard_txn_reference = str(random.randint(1000000, 1000000000))
    
    def lookup_biin(self, card_input):
        """Lookup card issuer information using BIN/BIIN"""
        
        # Accepts 6-digit BIN, 8-digit BIIN, or full card number
        if len(card_input) >= 8:
            mobicard_card_biin = card_input[:8]
        elif len(card_input) >= 6:
            mobicard_card_biin = card_input[:6]
        else:
            return {'status': 'ERROR', 'error_message': 'Invalid card input - must be at least 6 digits'}
        
        # Create JWT Header
        jwt_header = {"typ": "JWT", "alg": "HS256"}
        encoded_header = base64.urlsafe_b64encode(
            json.dumps(jwt_header).encode()
        ).decode().rstrip('=')
        
        # Create JWT Payload
        jwt_payload = {
            "mobicard_version": self.mobicard_version,
            "mobicard_mode": self.mobicard_mode,
            "mobicard_merchant_id": self.mobicard_merchant_id,
            "mobicard_api_key": self.mobicard_api_key,
            "mobicard_service_id": self.mobicard_service_id,
            "mobicard_service_type": self.mobicard_service_type,
            "mobicard_token_id": self.mobicard_token_id,
            "mobicard_txn_reference": self.mobicard_txn_reference,
            "mobicard_card_biin": mobicard_card_biin
        }
        
        encoded_payload = base64.urlsafe_b64encode(
            json.dumps(jwt_payload).encode()
        ).decode().rstrip('=')
        
        # Generate Signature
        header_payload = f"{encoded_header}.{encoded_payload}"
        signature = hmac.new(
            self.mobicard_secret_key.encode(),
            header_payload.encode(),
            hashlib.sha256
        ).digest()
        encoded_signature = base64.urlsafe_b64encode(signature).decode().rstrip('=')
        
        jwt_token = f"{encoded_header}.{encoded_payload}.{encoded_signature}"
        
        # Make API Call
        url = "https://mobicardsystems.com/api/v1/biin_lookup"
        payload = {"mobicard_auth_jwt": jwt_token}
        
        try:
            response = requests.post(url, json=payload, verify=False, timeout=30)
            response_data = response.json()
            
            if response_data.get('status') == 'SUCCESS':
                return {
                    'status': 'SUCCESS',
                    'card_scheme': response_data['card_biin_information']['card_biin_scheme'],
                    'issuer_bank': response_data['card_biin_information']['card_biin_bank_name'],
                    'card_type': response_data['card_biin_information']['card_biin_type'],
                    'country': response_data['card_biin_information']['card_biin_country_name'],
                    'is_prepaid': response_data['card_biin_information']['card_biin_prepaid'],
                    'raw_response': response_data
                }
            else:
                return {
                    'status': 'ERROR',
                    'status_code': response_data.get('status_code'),
                    'status_message': response_data.get('status_message')
                }
                
        except Exception as e:
            return {'status': 'ERROR', 'error_message': str(e)}

# Usage
biin_lookup = MobicardBiinLookup(
    merchant_id="4",
    api_key="YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
    secret_key="NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
)

# Can use 6-digit BIN, 8-digit BIIN, or full card number
result = biin_lookup.lookup_biin("5173350006475601")  # Full card number
# result = biin_lookup.lookup_biin("51733500")  # 8-digit BIIN
# result = biin_lookup.lookup_biin("517335")    # 6-digit BIN

if result['status'] == 'SUCCESS':
    print(f"Card Scheme: {result['card_scheme']}")
    print(f"Issuer Bank: {result['issuer_bank']}")
    print(f"Card Type: {result['card_type']}")
    print(f"Country: {result['country']}")
    print(f"Prepaid: {result['is_prepaid']}")
    
    if result['is_prepaid'] == 'Yes':
        print("Note: Prepaid card detected - apply appropriate risk rules.")
else:
    print(f"Error: {result.get('status_message')}")

const crypto = require('crypto');
const axios = require('axios');

class MobicardBiinLookup {
    constructor(merchantId, apiKey, secretKey) {
        this.mobicardVersion = "2.0";
        this.mobicardMode = "LIVE";
        this.mobicardMerchantId = merchantId;
        this.mobicardApiKey = apiKey;
        this.mobicardSecretKey = secretKey;
        this.mobicardServiceId = "20000";
        this.mobicardServiceType = "BIINLOOKUP";
        
        this.mobicardTokenId = Math.floor(Math.random() * (1000000000 - 1000000 + 1)) + 1000000;
        this.mobicardTxnReference = Math.floor(Math.random() * (1000000000 - 1000000 + 1)) + 1000000;
    }

    generateJWT(cardInput) {
        // Accepts 6-digit BIN, 8-digit BIIN, or full card number
        let mobicardCardBiin;
        if (cardInput.length >= 8) {
            mobicardCardBiin = cardInput.substring(0, 8);
        } else if (cardInput.length >= 6) {
            mobicardCardBiin = cardInput.substring(0, 6);
        } else {
            throw new Error('Invalid card input - must be at least 6 digits');
        }

        const jwtHeader = { typ: "JWT", alg: "HS256" };
        const encodedHeader = Buffer.from(JSON.stringify(jwtHeader)).toString('base64url');

        const jwtPayload = {
            mobicard_version: this.mobicardVersion,
            mobicard_mode: this.mobicardMode,
            mobicard_merchant_id: this.mobicardMerchantId,
            mobicard_api_key: this.mobicardApiKey,
            mobicard_service_id: this.mobicardServiceId,
            mobicard_service_type: this.mobicardServiceType,
            mobicard_token_id: this.mobicardTokenId.toString(),
            mobicard_txn_reference: this.mobicardTxnReference.toString(),
            mobicard_card_biin: mobicardCardBiin
        };

        const encodedPayload = Buffer.from(JSON.stringify(jwtPayload)).toString('base64url');

        const headerPayload = `${encodedHeader}.${encodedPayload}`;
        const signature = crypto.createHmac('sha256', this.mobicardSecretKey)
            .update(headerPayload)
            .digest('base64url');

        return `${encodedHeader}.${encodedPayload}.${signature}`;
    }

    async lookupBiin(cardInput) {
        try {
            const jwtToken = this.generateJWT(cardInput);
            
            const url = "https://mobicardsystems.com/api/v1/biin_lookup";
            const payload = { mobicard_auth_jwt: jwtToken };

            const response = await axios.post(url, payload, {
                httpsAgent: new (require('https').Agent)({ rejectUnauthorized: false })
            });

            const responseData = response.data;

            if (responseData.status === 'SUCCESS') {
                return {
                    status: 'SUCCESS',
                    cardScheme: responseData.card_biin_information.card_biin_scheme,
                    issuerBank: responseData.card_biin_information.card_biin_bank_name,
                    cardType: responseData.card_biin_information.card_biin_type,
                    country: responseData.card_biin_information.card_biin_country_name,
                    isPrepaid: responseData.card_biin_information.card_biin_prepaid,
                    rawResponse: responseData
                };
            } else {
                return {
                    status: 'ERROR',
                    statusCode: responseData.status_code,
                    statusMessage: responseData.status_message
                };
            }
        } catch (error) {
            return {
                status: 'ERROR',
                errorMessage: error.message
            };
        }
    }
}

// Usage
async function main() {
    const biinLookup = new MobicardBiinLookup(
        "4",
        "YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
        "NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
    );

    // Can use 6-digit BIN, 8-digit BIIN, or full card number
    const result = await biinLookup.lookupBiin("5173350006475601"); // Full card number
    // const result = await biinLookup.lookupBiin("51733500"); // 8-digit BIIN
    // const result = await biinLookup.lookupBiin("517335");   // 6-digit BIN

    if (result.status === 'SUCCESS') {
        console.log("BIIN Lookup Successful!");
        console.log(`Card Scheme: ${result.cardScheme}`);
        console.log(`Issuer Bank: ${result.issuerBank}`);
        console.log(`Card Type: ${result.cardType}`);
        console.log(`Country: ${result.country}`);
        console.log(`Prepaid: ${result.isPrepaid}`);
        
        if (result.isPrepaid === 'Yes') {
            console.log("Note: Prepaid card detected - apply appropriate risk rules.");
        }
    } else {
        console.log(`Error: ${result.statusMessage}`);
    }
}

main();

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Base64;
import java.util.Random;
import java.util.HashMap;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class MobicardBiinLookup {
    
    private final String mobicardVersion = "2.0";
    private final String mobicardMode = "LIVE";
    private final String mobicardMerchantId;
    private final String mobicardApiKey;
    private final String mobicardSecretKey;
    private final String mobicardServiceId = "20000";
    private final String mobicardServiceType = "BIINLOOKUP";
    
    private final String mobicardTokenId;
    private final String mobicardTxnReference;
    
    private final Gson gson = new Gson();
    
    public MobicardBiinLookup(String merchantId, String apiKey, String secretKey) {
        this.mobicardMerchantId = merchantId;
        this.mobicardApiKey = apiKey;
        this.mobicardSecretKey = secretKey;
        
        Random random = new Random();
        this.mobicardTokenId = String.valueOf(random.nextInt(900000000) + 1000000);
        this.mobicardTxnReference = String.valueOf(random.nextInt(900000000) + 1000000);
    }
    
    public String generateJWT(String cardInput) throws Exception {
        // Accepts 6-digit BIN, 8-digit BIIN, or full card number
        String mobicardCardBiin;
        if (cardInput.length() >= 8) {
            mobicardCardBiin = cardInput.substring(0, 8);
        } else if (cardInput.length() >= 6) {
            mobicardCardBiin = cardInput.substring(0, 6);
        } else {
            throw new Exception("Invalid card input - must be at least 6 digits");
        }
        
        Map jwtHeader = new HashMap<>();
        jwtHeader.put("typ", "JWT");
        jwtHeader.put("alg", "HS256");
        String encodedHeader = base64UrlEncode(gson.toJson(jwtHeader));
        
        Map jwtPayload = new HashMap<>();
        jwtPayload.put("mobicard_version", mobicardVersion);
        jwtPayload.put("mobicard_mode", mobicardMode);
        jwtPayload.put("mobicard_merchant_id", mobicardMerchantId);
        jwtPayload.put("mobicard_api_key", mobicardApiKey);
        jwtPayload.put("mobicard_service_id", mobicardServiceId);
        jwtPayload.put("mobicard_service_type", mobicardServiceType);
        jwtPayload.put("mobicard_token_id", mobicardTokenId);
        jwtPayload.put("mobicard_txn_reference", mobicardTxnReference);
        jwtPayload.put("mobicard_card_biin", mobicardCardBiin);
        
        String encodedPayload = base64UrlEncode(gson.toJson(jwtPayload));
        
        String headerPayload = encodedHeader + "." + encodedPayload;
        String signature = generateHMAC(headerPayload, mobicardSecretKey);
        
        return encodedHeader + "." + encodedPayload + "." + signature;
    }
    
    public JsonObject lookupBiin(String cardInput) throws Exception {
        String jwtToken = generateJWT(cardInput);
        
        HttpClient client = HttpClient.newHttpClient();
        
        Map requestBody = new HashMap<>();
        requestBody.put("mobicard_auth_jwt", jwtToken);
        
        String jsonBody = gson.toJson(requestBody);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://mobicardsystems.com/api/v1/biin_lookup"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        return gson.fromJson(response.body(), JsonObject.class);
    }
    
    private String base64UrlEncode(String data) {
        return Base64.getUrlEncoder().withoutPadding().encodeToString(data.getBytes());
    }
    
    private String generateHMAC(String data, String key) throws Exception {
        Mac sha256Hmac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "HmacSHA256");
        sha256Hmac.init(secretKey);
        byte[] hmacBytes = sha256Hmac.doFinal(data.getBytes());
        return base64UrlEncode(new String(hmacBytes));
    }
    
    public static void main(String[] args) {
        try {
            MobicardBiinLookup biinLookup = new MobicardBiinLookup(
                "4",
                "YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
                "NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
            );
            
            // Can use 6-digit BIN, 8-digit BIIN, or full card number
            String cardInput = "5173350006475601"; // Full card number
            // String cardInput = "51733500"; // 8-digit BIIN
            // String cardInput = "517335";   // 6-digit BIN
            
            JsonObject result = biinLookup.lookupBiin(cardInput);
            
            if (result.has("status")) {
                String status = result.get("status").getAsString();
                
                if ("SUCCESS".equals(status)) {
                    System.out.println("BIIN Lookup Successful!");
                    
                    if (result.has("card_biin_information")) {
                        JsonObject biinInfo = result.getAsJsonObject("card_biin_information");
                        
                        System.out.println("Card Scheme: " + 
                            biinInfo.get("card_biin_scheme").getAsString());
                        System.out.println("Issuer Bank: " + 
                            biinInfo.get("card_biin_bank_name").getAsString());
                        System.out.println("Card Type: " + 
                            biinInfo.get("card_biin_type").getAsString());
                        System.out.println("Country: " + 
                            biinInfo.get("card_biin_country_name").getAsString());
                        System.out.println("Prepaid: " + 
                            biinInfo.get("card_biin_prepaid").getAsString());
                        
                        if ("Yes".equals(biinInfo.get("card_biin_prepaid").getAsString())) {
                            System.out.println("Note: Prepaid card detected - apply appropriate risk rules.");
                        }
                    }
                } else {
                    System.out.println("BIIN Lookup Failed!");
                    if (result.has("status_message")) {
                        System.out.println("Error: " + result.get("status_message").getAsString());
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}