Vehicle RC Verification API: Complete Developer Guide

Vehicle RC verification is one of the most-used APIs in Indian B2B software. Insurance companies use it at policy issuance. Logistics platforms use it for driver onboarding. Used-car marketplaces use it to authenticate listings. Lending platforms use it for vehicle-backed loans.

This guide is the definitive developer reference for building vehicle RC verification into any product. It covers data sources, complete field reference, integration patterns, error handling, and production best practices.

By the end, you'll know everything required to ship a production-grade implementation with the API Express Vehicle RC Verification API.

What is Vehicle RC Verification?

Every vehicle in India has a Registration Certificate (RC) — issued by the state RTO when the vehicle is registered. The RC contains official details about the vehicle and its registered owner.

A Vehicle RC Verification API queries the government's VAHAN database (the national vehicle registration system) in real time and returns the RC details for any vehicle registration number. Instead of physically inspecting the RC document, you send the RC number to the API and get a structured JSON response in under 100 milliseconds.

The RC number format is standard across India:

• State code — 2 letters (MH = Maharashtra, DL = Delhi, KA = Karnataka)
• RTO code — 2 digits (12 = Pune RTO, 01 = Delhi Central RTO)
• Series — 1-2 letters (AB, CD)
• Number — 4 digits (1234)

For example: MH12AB1234 is a vehicle registered in Pune, Maharashtra.

Why It Matters for Indian Businesses

Manual RC verification — collecting physical documents, cross-checking details, and following up on discrepancies — takes 15-20 minutes per vehicle. At scale, this becomes an operational bottleneck.

More importantly, manual verification is unreliable. Fake RC documents are common. Falsified insurance details slip through. Chassis and engine numbers don't always match the physical vehicle.

Vehicle RC Verification API solves both problems:

• 20 minutes → 2 seconds — Verification happens in real time, as part of your onboarding flow
• Zero document fraud — Data comes directly from VAHAN, not from documents you're trusting
• Scales to any volume — Handle 10 or 10,000 verifications per day with the same code

Data Sources & Accuracy

Vehicle RC Verification API data comes from VAHAN — the National Vehicle Register maintained by the Ministry of Road Transport and Highways (MoRTH). VAHAN is the same database used by:

• State RTOs for issuing and updating RCs
• Traffic police for enforcing vehicle compliance
• Insurance companies for regulatory reporting

Our API queries VAHAN directly through authorised channels, applies data transformations (masking PII for privacy), and returns a clean JSON response.

Accuracy characteristics

Factor	Details
Overall accuracy	99%+ for valid RC numbers
Coverage	All 28 states + 8 UTs, all 22+ RTOs under VAHAN
Update frequency	Source-updated; changes reflect within minutes
Response time	<100ms average
Old/non-digitised RCs	May return partial data; response flags this clearly

Complete Field Reference

Every successful response includes the following fields. Field names are consistent across all API Express endpoints.

Vehicle details

Field	Type	Example
rc_number	string	MH12AB1234
vehicle_class	string	Motor Car (LMV)
maker_model	string	Honda City VX
fuel_type	string	Petrol
manufacturing_year	integer	2019
chassis_number	string	MAKGM4A20K1234567
engine_number	string	L15B7ABC123456
cubic_capacity	integer	1497
seating_capacity	integer	5

Owner details (masked)

Field	Type	Example
owner_name	string	R***sh K***r
owner_serial	string	1 (first owner), 2 (second owner)

Registration & compliance

Field	Type	Example
registration_date	date	2019-04-15
rc_valid_until	date	2034-04-14
insurance_valid	boolean	true
insurance_company	string	HDFC ERGO
insurance_expiry	date	2027-03-31
pucc_valid	boolean	true
fitness_valid	boolean	true

Location

Field	Type	Example
rto_code	string	MH12
rto_location	string	Pune, Maharashtra
state	string	Maharashtra

Integration Guide

Let's build a working integration. We'll use Node.js for this example, but the same pattern works in any language.

Basic request

Node.js

const response = await fetch(
  'https://api.apiexpress.in/v1/rc/verify',
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      rc_number: 'MH12AB1234'
    })
  }
);

const data = await response.json();
console.log(data);

Response structure

JSON

{
  "status": "success",
  "rc_number": "MH12AB1234",
  "owner_name": "R***sh K***r",
  "owner_serial": "1",
  "vehicle_class": "Motor Car (LMV)",
  "maker_model": "Honda City VX",
  "fuel_type": "Petrol",
  "manufacturing_year": 2019,
  "chassis_number": "MAKGM4A20K1234567",
  "engine_number": "L15B7ABC123456",
  "cubic_capacity": 1497,
  "seating_capacity": 5,
  "registration_date": "2019-04-15",
  "rc_valid_until": "2034-04-14",
  "insurance_valid": true,
  "insurance_company": "HDFC ERGO",
  "insurance_expiry": "2027-03-31",
  "pucc_valid": true,
  "fitness_valid": true,
  "rto_code": "MH12",
  "rto_location": "Pune, Maharashtra",
  "state": "Maharashtra"
}

Python example

Python

import os
import requests

response = requests.post(
    'https://api.apiexpress.in/v1/rc/verify',
    headers={
        'Authorization': f'Bearer {os.environ["API_KEY"]}',
        'Content-Type': 'application/json'
    },
    json={'rc_number': 'MH12AB1234'}
)

data = response.json()
print(data['maker_model'])  # Honda City VX
print(data['insurance_valid'])  # True

Common Integration Patterns

Depending on your use case, you'll integrate RC verification in one of three ways:

Pattern 1: Real-time verification (single RC)

Best for: driver onboarding, used-car listing authentication, single-vehicle checks during user flows.

Call the API synchronously during the user's action. Return results immediately.

JavaScript

async function verifyDriverVehicle(rcNumber) {
  const response = await client.rc.verify({ rc_number: rcNumber });

  if (!response.insurance_valid) {
    return {
      approved: false,
      reason: 'Vehicle insurance has expired'
    };
  }

  return {
    approved: true,
    vehicle: response.maker_model,
    owner: response.owner_name
  };
}

Pattern 2: Bulk verification (batch of RCs)

Best for: mass onboarding, periodic fleet re-verification, insurance policy book audits.

Submit up to 10,000 RCs per batch. Results returned asynchronously via webhook.

JavaScript

const batch = await client.rc.verifyBulk({
  rc_numbers: ['MH12AB1234', 'DL01CD5678', 'KA05XY9012'],
  webhook_url: 'https://yourapp.com/webhooks/rc-bulk'
});

console.log(batch.batch_id);  // 'batch_a1b2c3d4'
// Results arrive at webhook_url when ready

Pattern 3: Webhook-driven processing

Best for: async operations that need to trigger downstream workflows.

JavaScript

app.post('/webhooks/rc-bulk',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    const event = JSON.parse(req.body.toString());

    if (event.type === 'verification.bulk.completed') {
      // Download results, process, update database
      processBatchResults(event.data.batch_id);
    }

    res.status(200).send('OK');
  }
);

Error Handling

Every error returns a structured response with a specific code. Handle each case explicitly:

Code	Meaning	Action
INVALID_RC_NUMBER	Not a valid Indian RC format	Show validation error to user
NOT_FOUND	RC not found in VAHAN	Ask user to verify the number
PARTIAL_DATA	Old RC, limited fields returned	Proceed with caution, flag for review
RATE_LIMIT_EXCEEDED	Too many requests	Wait and retry with backoff
UPSTREAM_ERROR	VAHAN temporarily unavailable	Retry with exponential backoff

Recommended error handling

JavaScript

try {
  const result = await client.rc.verify({ rc_number: rcNumber });
  return { success: true, data: result };

} catch (error) {
  switch (error.code) {
    case 'INVALID_RC_NUMBER':
      return {
        success: false,
        userMessage: 'Please enter a valid RC number (e.g., MH12AB1234)'
      };

    case 'NOT_FOUND':
      return {
        success: false,
        userMessage: 'Vehicle not found. Please check the RC number and try again.'
      };

    case 'PARTIAL_DATA':
      // Log but proceed with available data
      console.warn('Partial data for RC:', rcNumber);
      return { success: true, data: error.partialData, review: true };

    case 'RATE_LIMIT_EXCEEDED':
      // Retry after delay
      await sleep(error.retryAfter * 1000);
      return retry();

    case 'UPSTREAM_ERROR':
      // Retry with exponential backoff
      return retryWithBackoff();
  }
}

Production Best Practices

Cache results wisely

RC data changes rarely (ownership transfers, insurance renewals). Cache aggressively:

• Registration details (owner, chassis, engine) — Cache for 30+ days
• Insurance status — Cache for 24-48 hours (changes more often)
• PUCC / fitness — Cache for 24 hours

Cache key should be the RC number. Invalidate on any manual re-verification request.

Use idempotency keys

When verifying the same RC in a retryable workflow, use the same ref_id. This ensures duplicates don't count against your quota if the retry succeeds on our side.

Log request IDs for support

Every response includes a request_id. Log it with every verification. If you need to contact support about a specific vehicle lookup, this ID lets us trace the exact request in our logs.

Handle partial data explicitly

Old RCs (pre-digitisation) may return partial data. Your application should handle this gracefully — either flagging the record for manual review, or accepting the partial data with documented limitations.

Monitor for anomalies

Set up alerts on:

• Error rate spikes (indicates upstream VAHAN issue)
• Response time increases (indicates network or scaling issue)
• Unexpected NOT_FOUND rates (may indicate a bad input source)
• Insurance expiry patterns (potential fraud signal for lending/insurance use cases)

Real Use Cases by Industry

Different industries use RC verification for different purposes. Here's how:

Insurance companies

Verify vehicle details and insurance history at policy issuance. Authenticate vehicles during claims. Reduce fraud from fake RC documents and misrepresented vehicle history.

Read more: APIs for Insurance & Legal →

Logistics & fleet platforms

Verify driver vehicles during onboarding. Confirm RC validity, insurance status, and vehicle class. Automate compliance checks across national fleets.

Read more: APIs for Logistics & Fleet →

Used-car marketplaces

Authenticate listings automatically. Show buyers verified vehicle history. Build trust and reduce post-sale disputes.

Vehicle-backed lending

Verify registration and ownership before loan origination. Confirm chassis and engine numbers during physical inspection. Track vehicle status throughout the loan lifecycle.

Read more: APIs for Fintech & NBFC →

Legal & recovery firms

Trace vehicle ownership for legal proceedings. Verify ownership during asset recovery. Access all-India RTO data through a single interface.

Summary

Vehicle RC Verification is a foundational API for any product that deals with vehicles in India. Key takeaways:

• Data source matters — Always use VAHAN-sourced APIs for authoritative data
• Response time is fast — Under 100ms for real-time use cases
• Handle partial data — Old RCs may return incomplete records
• Cache appropriately — Registration data rarely changes; insurance status changes more often
• Match your integration pattern — Real-time for single checks, bulk for mass operations

If you're building a product that touches vehicles — insurance, logistics, lending, marketplaces — start with a free API Express account. 1,000 free verifications, no credit card required.

Questions? Reach out to our team. We respond within 4 hours on business days.