PHP code example of bvn-verification / bvn-verification-php

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

bvn-verification / bvn-verification-php example snippets

VNVerification\BVNVerifier;

// Initialize verifier (mock mode for testing)
$verifier = new BVNVerifier('your-api-key', true, 'json-mock');

// Verify BVN
$result = $verifier->verify('12345678901', 'JOHN DOE');

if ($result->isMatch()) {
    echo "✅ BVN verified successfully!";
    echo "Registered Name: " . $result->getVerifiedName();
} else {
    echo "❌ Verification failed: " . $result->message;
}

use BVNVerification\BVNVerifier;

// Production mode (real NIBSS API)
$verifier = new BVNVerifier(
    'your-nibss-api-key',  // API key from NIBSS
    false,                 // sandbox mode (false for production)
    'live'                 // mode: 'live' for real API
);

// Development mode (mock data)
$verifier = new BVNVerifier(
    'mock-key',            // any string for mock mode
    true,                  // sandbox mode (true for testing)
    'json-mock'            // mode: 'json-mock' for mock data
);

namespace App\Http\Controllers;

use BVNVerification\Laravel\Facades\BVNVerifier;

class VerificationController extends Controller
{
    public function verifyCustomer(Request $request)
    {
        $result = BVNVerifier::verify($request->bvn, $request->full_name);
        
        return response()->json([
            'verified' => $result->isMatch(),
            'registered_name' => $result->getVerifiedName(),
            'message' => $result->message
        ]);
    }
}

namespace App\Http\Controllers;

use BVNVerification\BVNVerifier;

class VerificationController extends Controller
{
    public function verifyCustomer(Request $request, BVNVerifier $verifier)
    {
        $result = $verifier->verify($request->bvn, $request->full_name);
        
        if ($result->isMatch()) {
            // Proceed with verified user
            return redirect('/dashboard')->with('success', 'BVN verified!');
        }
        
        return back()->with('error', 'BVN verification failed: ' . $result->message);
    }
}

VNVerification\BVNVerifier;

$verifier = new BVNVerifier('mock-key', true, 'json-mock');

$customers = [
    ['bvn' => '12345678901', 'name' => 'JOHN DOE'],
    ['bvn' => '98765432109', 'name' => 'JANE SMITH'],
    ['bvn' => '12345678901', 'name' => 'WRONG NAME'] // This will fail
];

foreach ($customers as $customer) {
    $result = $verifier->verify($customer['bvn'], $customer['name']);
    
    echo "BVN: {$customer['bvn']}\n";
    echo "Name: {$customer['name']}\n";
    echo "Status: " . ($result->isMatch() ? 'VERIFIED' : 'FAILED') . "\n";
    
    if ($result->getVerifiedName()) {
        echo "Registered Name: {$result->getVerifiedName()}\n";
    }
    
    echo "Message: {$result->message}\n";
    echo "------------------------\n";
}

VNVerification\BVNVerifier;

class BVNService
{
    private $verifier;
    
    public function __construct()
    {
        $this->verifier = new BVNVerifier('mock-key', true, 'json-mock');
    }
    
    public function processBatch(array $applications): array
    {
        $results = [];
        
        foreach ($applications as $app) {
            try {
                $result = $this->verifier->verify($app['bvn'], $app['full_name']);
                
                $results[] = [
                    'application_id' => $app['id'],
                    'bvn' => $app['bvn'],
                    'verified' => $result->isMatch(),
                    'registered_name' => $result->getVerifiedName(),
                    'status' => $result->status,
                    'message' => $result->message,
                    'timestamp' => date('Y-m-d H:i:s')
                ];
            } catch (Exception $e) {
                $results[] = [
                    'application_id' => $app['id'],
                    'bvn' => $app['bvn'],
                    'verified' => false,
                    'error' => $e->getMessage(),
                    'timestamp' => date('Y-m-d H:i:s')
                ];
            }
        }
        
        return $results;
    }
}

// Usage
$service = new BVNService();
$applications = [
    ['id' => 1, 'bvn' => '12345678901', 'full_name' => 'JOHN DOE'],
    ['id' => 2, 'bvn' => '98765432109', 'full_name' => 'JANE SMITH'],
];

$results = $service->processBatch($applications);
print_r($results);

$result = $verifier->verify('12345678901', 'JOHN DOE');

if ($result->isMatch()) {
    // Verification successful
    $registeredName = $result->getVerifiedName();
} else {
    // Verification failed
    $errorMessage = $result->message;
}

if ($verifier->supportsBVNRecords()) {
    $records = $verifier->getBVNRecords();
    foreach ($records as $record) {
        echo "BVN: {$record['bvn']} - Name: {$record['registered_name']}\n";
    }
}

$verifier->setMode('live'); // Switch to live NIBSS API
$verifier->setMode('json-mock'); // Switch back to mock mode

$verifier->setSandboxMode(false); // Disable sandbox (production)

$verifier = new BVNVerifier('any-key', true, 'json-mock');

// Test with sample data
$testCases = [
    ['12345678901', 'JOHN DOE'],     // ✅ Match
    ['98765432109', 'JANE SMITH'],   // ✅ Match  
    ['12345678901', 'WRONG NAME'],   // ❌ Mismatch
    ['00000000000', 'ANY NAME'],     // ❌ BVN not found
];

foreach ($testCases as $test) {
    $result = $verifier->verify($test[0], $test[1]);
    // Process results...
}

$verifier = new BVNVerifier(
    'your-production-api-key',
    false, // sandbox mode OFF
    'live' // live mode
);

try {
    $result = $verifier->verify($bvn, $customerName);
    
    if ($result->isMatch()) {
        // Success - proceed with verified user
        $this->createUserAccount($customerData);
    } else {
        // Verification failed
        throw new Exception('BVN verification failed: ' . $result->message);
    }
} catch (\BVNVerification\Exceptions\VerificationException $e) {
    // Handle verification-specific errors
    Log::error('BVN Verification Error: ' . $e->getMessage());
    return response()->json(['error' => 'Verification service unavailable'], 503);
} catch (\Exception $e) {
    // Handle other errors
    Log::error('BVN Service Error: ' . $e->getMessage());
    return response()->json(['error' => 'Service temporarily unavailable'], 500);
}

try {
    $result = $verifier->verify('123', 'John Doe'); // Too short
} catch (\BVNVerification\Exceptions\VerificationException $e) {
    echo "Error: " . $e->getMessage(); // "BVN must be exactly 11 digits"
}

try {
    $result = $verifier->verify('12345678901', 'John Doe');
} catch (\BVNVerification\Exceptions\AuthenticationException $e) {
    // Invalid API key or authentication failed
    Log::error('Authentication failed: ' . $e->getMessage());
} catch (\BVNVerification\Exceptions\VerificationException $e) {
    // Other verification errors
    Log::error('Verification error: ' . $e->getMessage());
}

public function verifyCustomerBVN($bvn, $customerName)
{
    try {
        // Validate input first
        if (empty($bvn) || empty($customerName)) {
            throw new InvalidArgumentException('BVN and customer name are bvn,
            'provided_name' => $customerName,
            'verified' => $result->isMatch(),
            'registered_name' => $result->getVerifiedName()
        ]);
        
        return $result;
        
    } catch (\BVNVerification\Exceptions\VerificationException $e) {
        Log::error('BVN verification service error', [
            'bvn' => $bvn,
            'error' => $e->getMessage()
        ]);
        throw new ServiceUnavailableException('Verification service temporarily unavailable');
    } catch (Exception $e) {
        Log::error('Unexpected BVN verification error', [
            'bvn' => $bvn,
            'error' => $e->getMessage()
        ]);
        throw $e;
    }
}

namespace Tests\Feature;

use Tests\TestCase;
use BVNVerification\Laravel\Facades\BVNVerifier;

class BVNVerificationTest extends TestCase
{
    public function test_successful_bvn_verification()
    {
        $result = BVNVerifier::verify('12345678901', 'JOHN DOE');
        
        $this->assertTrue($result->isMatch());
        $this->assertEquals('JOHN DOE', $result->getVerifiedName());
    }
    
    public function test_failed_bvn_verification()
    {
        $result = BVNVerifier::verify('12345678901', 'WRONG NAME');
        
        $this->assertFalse($result->isMatch());
        $this->assertStringContainsString('does not match', $result->message);
    }
    
    public function test_invalid_bvn_format()
    {
        $this->expectException(\BVNVerification\Exceptions\VerificationException::class);
        
        BVNVerifier::verify('123', 'John Doe');
    }
}

VNVerification\BVNVerifier;

class BVNVerificationTest
{
    private $verifier;
    
    public function setUp()
    {
        $this->verifier = new BVNVerifier('test-key', true, 'json-mock');
    }
    
    public function testVerification()
    {
        $result = $this->verifier->verify('12345678901', 'JOHN DOE');
        
        assert($result->isMatch() === true, 'Should verify successfully');
        assert($result->getVerifiedName() === 'JOHN DOE', 'Should return registered name');
        
        echo "✅ All tests passed!\n";
    }
}

$test = new BVNVerificationTest();
$test->setUp();
$test->testVerification();

public function registerCustomer(Request $request)
{
    $validated = $request->validate([
        'bvn' => 'uired|string'
    ]);
    
    // Verify BVN
    $verificationResult = BVNVerifier::verify(
        $validated['bvn'], 
        $validated['full_name']
    );
    
    if (!$verificationResult->isMatch()) {
        return back()->withErrors([
            'bvn' => 'BVN verification failed. Please ensure your BVN and name match your bank records.'
        ]);
    }
    
    // Create customer account
    $customer = Customer::create([
        'bvn' => $validated['bvn'],
        'verified_name' => $verificationResult->getVerifiedName(),
        'email' => $validated['email'],
        'phone' => $validated['phone'],
        'bvn_verified_at' => now()
    ]);
    
    return redirect('/dashboard')->with('success', 'Account created successfully!');
}

public function submitLoanApplication(Request $request)
{
    $verificationResult = BVNVerifier::verify(
        $request->bvn,
        $request->full_name
    );
    
    if ($verificationResult->isMatch()) {
        $application = LoanApplication::create([
            'user_id' => auth()->id(),
            'bvn' => $request->bvn,
            'verified_name' => $verificationResult->getVerifiedName(),
            'amount' => $request->amount,
            'status' => 'under_review'
        ]);
        
        return response()->json([
            'success' => true,
            'application_id' => $application->id,
            'message' => 'Loan application submitted for review'
        ]);
    }
    
    return response()->json([
        'success' => false,
        'message' => 'BVN verification failed. Please check your details.'
    ], 422);
}

bash
php artisan vendor:publish --provider="BVNVerification\\Laravel\\BVNVerificationServiceProvider"