Driving License Verification

Endpoint Overview

POST /api/v1/driving-license/driving-license

Description

The Driving License Verification API enables real-time verification and extraction of driving license details from India's official government database. By submitting a license number along with the holder's date of birth, this API retrieves comprehensive information about the license holder — including personal details, address information, vehicle classes authorized, validity dates, and a profile image — all in a single API call.

This API is particularly valuable for organizations that need to verify the identity of individuals and validate the authenticity of their driving credentials without manual document checks. It eliminates the need for physical document verification, significantly reducing onboarding time and operational costs while improving accuracy and compliance.

Key Benefits

Instant Verification: Retrieve verified driving license data in real time directly from authoritative government sources, eliminating delays associated with manual verification.

Comprehensive Data Extraction: Access a rich set of fields including personal details, permanent and temporary addresses, vehicle class authorizations, license validity dates, and even a Base64-encoded profile image — all in one response.

Fraud Prevention: Cross-validate user-submitted information against official records to detect discrepancies and prevent identity fraud during onboarding or service access.

Seamless Integration: A simple REST-based interface with JWT authentication makes it easy to embed license verification into any existing application, workflow, or KYC pipeline.

Use Cases

Financial Services

Mobility & Transportation

Government & HR

Loan & Credit Onboarding: Banks and NBFCs can verify a borrower's identity using their driving license during digital loan applications, ensuring the applicant is who they claim to be before disbursement.

Account Opening & KYC: Financial institutions can use this API to fulfill RBI-mandated KYC norms by confirming identity and address details from the driving license during new account registrations.

Insurance Policy Issuance: Motor insurance providers can validate the driving license of applicants to ensure they are licensed to drive the vehicle being insured, reducing fraud and invalid claims.

Technical Implementation

Authentication

All requests to the Driving License Verification API must be authenticated using a JWT Bearer Token. Follow the steps below to authenticate successfully:

Obtain API Credentials: Register on the Surepass platform to receive your unique API key for the desired environment.

Use JWT Token as Bearer Token: Your JWT token (provided by Surepass) must be passed directly in the Authorization header of every request.

Include in Requests: Add the token to the Authorization header using the format Bearer <YOUR_JWT_TOKEN>.

⚠️ Important: Use the correct base URL and corresponding JWT token for each environment. Do not use sandbox tokens in production or vice versa.

Environment	Base URL
Sandbox	`https://sandbox.surepass.app`
Production	`https://kyc-api.surepass.app`

Request Parameters

Request Headers

Header	Required	Description
`Authorization`	Yes	Bearer token for authentication. Format: `Bearer <YOUR_JWT_TOKEN>`
`Content-Type`	Yes	Must be set to `application/json`

Request Body

Parameter	Type	Required	Description
`id_number`	`string`	Yes	The driving license number to be verified. This is the unique identifier issued by the RTO (e.g., `UP2020150000000`).
`dob`	`string`	Yes	Date of birth of the license holder in `YYYY-MM-DD` format (e.g., `1996-11-23`). Used to match and validate the license record.

Example Request

{
  "id_number": "UP2020150000000",
  "dob": "1996-11-23"
}

Process Response

Response Parameters

The API returns a structured JSON response. Below is a detailed description of each field in the response:

Top-Level Fields

Parameter	Type	Description
`data`	`object`	Contains the complete driving license details retrieved from the government database.
`status_code`	`integer`	HTTP status code of the response. `200` indicates a successful verification.
`message`	`string`	A message describing the result of the API call. Empty string on success.
`success`	`boolean`	Indicates whether the API call was successful. `true` for a successful response.

`data` Object Fields

Parameter	Type	Description
`client_id`	`string`	A unique identifier generated by Surepass for this specific verification transaction (e.g., `license_ForJHgPglDHkfAVBGTFx`).
`license_number`	`string`	The driving license number that was submitted in the request and verified.
`state`	`string`	The Indian state where the driving license was issued (e.g., `Uttar Pradesh`).
`name`	`string`	Full name of the driving license holder as recorded in the government database.
`permanent_address`	`string`	Permanent residential address of the license holder as registered with the RTO.
`permanent_zip`	`string`	PIN code corresponding to the permanent address of the license holder.
`city_name`	`string` \| `null`	City name of the license holder. May be `null` if not available in the government record.
`temporary_address`	`string`	Temporary or current residential address of the license holder.
`temporary_zip`	`string`	PIN code corresponding to the temporary address.
`citizenship`	`string`	Citizenship status of the license holder. May be an empty string if not recorded.
`ola_name`	`string`	Full name of the issuing licensing authority (Office of Licensing Authority), e.g., `DISTRICT TRANSPORT OFFICE, MIRZAPUR`.
`ola_code`	`string`	Short code identifying the issuing Office of Licensing Authority (e.g., `UP20`).
`gender`	`string`	Gender of the license holder. `M` for Male, `F` for Female.
`father_or_husband_name`	`string`	Name of the license holder's father or husband as recorded in the government database.
`dob`	`string`	Date of birth of the license holder in `YYYY-MM-DD` format as recorded in the government database.
`doe`	`string`	Date of expiry of the non-transport (personal) driving license in `YYYY-MM-DD` format.
`transport_doe`	`string`	Date of expiry of the transport vehicle authorization on the license in `YYYY-MM-DD` format. Value `1800-01-01` indicates no transport authorization.
`doi`	`string`	Date of issue (initial issuance date) of the driving license in `YYYY-MM-DD` format.
`transport_doi`	`string`	Date of issue of the transport authorization on the license in `YYYY-MM-DD` format. Value `1800-01-01` indicates no transport authorization.
`profile_image`	`string`	Base64-encoded profile photograph of the license holder as stored in the government database.
`has_image`	`boolean`	Indicates whether a profile image was successfully retrieved. `true` if an image is available.
`blood_group`	`string`	Blood group of the license holder as recorded on the driving license (e.g., `O-`).
`vehicle_classes`	`array[string]`	List of vehicle categories the license holder is authorized to drive (e.g., `["LMV", "MCWG"]`).
`less_info`	`boolean`	Indicates whether the returned data is a partial/limited dataset. `false` means full data was returned.
`additional_check`	`array`	Array containing results of any additional checks performed. Empty array if no additional checks were conducted.
`initial_doi`	`string`	The original date on which the driving license was first issued, in `YYYY-MM-DD` format.
`current_status`	`string` \| `null`	Current status of the driving license (e.g., active, suspended). May be `null` if not available.
`badge_number`	`array`	List of badge numbers associated with the license, if applicable. Empty array if not applicable.
`vehicle_class_description`	`array`	Descriptive information about each authorized vehicle class. Empty array if descriptions are not available.

Example Successful Response

{
  "data": {
    "client_id": "license_ForJHgPglDHkfAVBGTFx",
    "license_number": "UP2020150000000",
    "state": "Uttar Pradesh",
    "name": "MUNNA BHAIYA",
    "permanent_address": "TRIPATHI HAVELI, MIRZAPUR, UP",
    "permanent_zip": "231001",
    "city_name": null,
    "temporary_address": "TRIPATHI HAVELI, MIRZAPUR, UP",
    "temporary_zip": "231001",
    "citizenship": "",
    "ola_name": "DISTRICT TRANSPORT OFFICE, MIRZAPUR",
    "ola_code": "UP20",
    "gender": "M",
    "father_or_husband_name": "KALEEN BHAIYA",
    "dob": "1999-08-31",
    "doe": "2039-07-23",
    "transport_doe": "1800-01-01",
    "doi": "2012-07-24",
    "transport_doi": "1800-01-01",
    "profile_image": "/9j/4AAQSkZJRgABAQAAAQABAAD/2w",
    "has_image": true,
    "blood_group": "O-",
    "vehicle_classes": [
      "LMV",
      "MCWG"
    ],
    "less_info": false,
    "additional_check": [],
    "initial_doi": "2012-07-24",
    "current_status": null,
    "badge_number": [],
    "vehicle_class_description": []
  },
  "status_code": 200,
  "message": "",
  "success": true
}

Possible Error Responses

401 Unauthorized

400 Bad Request

404 Not Found

429 Too Many Requests

{
  "data": null,
  "status_code": 401,
  "message": "Authentication credentials were not provided or are invalid.",
  "success": false
}

This error occurs when the Authorization header is missing, malformed, or contains an invalid/expired JWT token. Ensure you are using a valid Bearer token for the correct environment (sandbox or production).

Integration Best Practices

Security Recommendations

Never expose your JWT token on the client side. All API calls to the Driving License Verification endpoint should be made from your backend server, keeping your token secure and out of reach of end users or browser-based code.

Rotate JWT tokens regularly. Treat your JWT tokens like passwords — rotate them periodically and immediately invalidate any token that you suspect has been compromised.

Use environment-specific tokens strictly. Always use the sandbox JWT token with https://sandbox.surepass.app and the production JWT token with https://kyc-api.surepass.app. Cross-environment token usage will result in authentication failures.

Validate inputs before making API calls. Enforce format validation on id_number (alphanumeric, state-prefixed format) and dob (YYYY-MM-DD) on your end before hitting the API to reduce unnecessary API calls and potential errors.

Handle Base64 profile images securely. If storing or displaying the profile_image field, ensure it is served over HTTPS and access is restricted to authorized users only, in compliance with applicable data protection laws.

User Experience Guidelines

Provide real-time feedback during verification. Show a loading/progress indicator to the user while the API call is in progress so they are aware the verification is ongoing and do not submit the form multiple times.

Display user-friendly error messages. Translate API error responses (e.g., 400, 404) into plain-language messages for end users, such as "We couldn't verify your license. Please double-check your license number and date of birth."

Pre-fill form fields from the API response. Use the returned data (e.g., name, permanent_address, dob) to auto-populate onboarding forms, reducing manual data entry and the chance of user input errors.

Clearly communicate data usage. Inform users at the point of license submission that their details will be verified against government records, building transparency and trust in your verification process.

Gracefully handle partial data scenarios. When less_info is true or certain fields like city_name or current_status return null, handle these cases gracefully in the UI without breaking the user flow.

Code Samples

cURL

Python

Node.js

🔁 Replace https://sandbox.surepass.app with https://kyc-api.surepass.app and use the production JWT token when moving to production.

Related APIs

Aadhaar Verification API: Verify an individual's identity using their 12-digit Aadhaar number against UIDAI records, useful for cross-referencing identity details retrieved from the Driving License API.

PAN Verification API: Validate a Permanent Account Number (PAN) against Income Tax Department records, commonly used alongside driving license verification in financial KYC workflows.

Vehicle RC Verification API: Retrieve and verify vehicle registration certificate (RC) details using a vehicle registration number — a natural companion to driving license verification in mobility and insurance use cases.

Passport Verification API: Verify passport details for identity verification use cases that require a government-issued travel document as proof of identity and nationality.

Compliance and Legal Considerations

Data Privacy Compliance: The personal data retrieved through this API (including name, address, date of birth, and profile image) is sensitive in nature. Ensure your application complies with applicable Indian data protection regulations, including the Digital Personal Data Protection Act, 2023 (DPDPA), and any sector-specific guidelines issued by RBI, IRDAI, or other regulators.

Purpose Limitation: Use the data retrieved through this API strictly for the stated and consented purpose (e.g., KYC, onboarding, identity verification). Do not use it for profiling, marketing, or any purpose not disclosed to the end user.

User Consent: Obtain explicit, informed consent from the individual whose driving license is being verified before initiating an API call. Maintain an auditable record of consent for compliance purposes.

Data Retention: Do not store sensitive fields such as profile_image, dob, or permanent_address longer than necessary. Define and enforce a clear data retention and deletion policy in accordance with applicable laws.

Authorized Use Only: This API must only be used for legitimate business verification purposes by authorized entities. Unauthorized or malicious use of this API to access individuals' personal data without consent may attract legal liability under applicable laws.

Provide your bearer token in the

Authorization

header when making requests to protected resources.

Example:

Authorization: Bearer ********************

License

Driving License Verification#

Description#

Use Cases#

Technical Implementation#

Request Headers#

Request Body#

Example Request#

Response Parameters#

Top-Level Fields#

data Object Fields#

Example Successful Response#

Possible Error Responses#

Integration Best Practices#

Code Samples#

Request

Responses