Verify Doctor Registration Number Online in India

Anas Nadeem

Anas Nadeem

Founder

1 August 202610 min read
image

If you need to verify doctor registration number online, the core question is simple: is this person listed as a registered medical practitioner in the official register? A name, degree, clinic website, or social media profile is not enough. You need a registration record that can be checked against the National Medical Commission's Indian Medical Register.
For one doctor, you can do this manually on the NMC website. For a hospital, telemedicine platform, insurance network, healthtech marketplace, or clinic chain, manual checking quickly becomes slow and inconsistent. This guide covers both flows: the public NMC method first, then the API method for business onboarding.


How to Verify Doctor Registration Number Online on NMC

The National Medical Commission maintains the Indian Medical Register (IMR), which is the public source many people use to check whether a doctor registration exists. The public route is useful when you are verifying one doctor at a time and can tolerate manual steps.

Go to the NMC website at https://www.nmc.org.in/. From the site navigation, open the information desk section and look for the Indian Medical Register. The direct page used for IMR lookup is usually:

https://www.nmc.org.in/information-desk/indian-medical-register/

Once you are on the Indian Medical Register page, search using the details you have:

  1. Enter the doctor's registration number.
  2. If available, select or enter the State Medical Council.
  3. You may also search by doctor name or registration year if the exact number is unclear.
  4. Submit the search.
  5. Review the matching records.
  6. Open the doctor detail view to confirm the full record.

The record can include the doctor's name, registration number, State Medical Council, registration date, qualification, qualification year, university, and current status. If there are multiple records with the same registration number across councils, the State Medical Council becomes important for disambiguation.

This manual process is good for personal checks, patient due diligence, small clinic checks, or a one-off internal review. It is also useful when your compliance team needs to independently review an exception.

Why Manual Doctor Verification Breaks for Businesses

Manual lookup looks simple until it becomes part of an onboarding workflow. If you onboard five doctors in a month, a person can check each record on NMC. If you onboard 500 doctors, the same process becomes operational drag.

The first issue is consistency. One operations executive may search by registration number. Another may search by name. A third may skip the State Medical Council when the registration number is ambiguous. The result is not just slower onboarding; it is inconsistent evidence.

The second issue is auditability. In a healthcare business, you need to know who checked the doctor, when the check happened, what input was used, and what result came back. A screenshot in a shared drive is weak evidence. It can be lost, renamed, or detached from the onboarding decision.

The third issue is routing. A valid doctor registration should move the doctor forward. A missing registration should stop onboarding. An ambiguous match should go to manual review. A source outage should retry later. Manual portals do not give your system these states in a structured way.

If you are building doctor onboarding, appointment booking, hospital empanelment, insurance provider verification, or medical marketplace workflows, this is the check you need to turn into a backend decision.

When to Use an API to Verify Doctor Registration Number Online

The Doctor Verification API lets your backend verify a doctor registration number against the NMC Indian Medical Register and receive a structured JSON response. You send the registration ID, and optionally the State Medical Council when you have it. The API returns fields your system can route.

This is not a replacement for your healthcare compliance policy. It is one credential check inside that policy. You still need consent handling, internal review rules, onboarding documentation, and any additional checks relevant to your business.

The API is useful because it separates the important states:

  • Registration number was found and is valid.
  • Registration number was not found.
  • Multiple records matched and State Medical Council is needed.
  • Source was unavailable and the request should be retried.
  • Your API key or account setup needs attention.

Successful response:

json
{
  "success": true,
  "verification_type": "doctor",
  "verification_data": {
    "is_valid": true,
    "doctor_name": "JOHN DOE",
    "registration_id": "2000010031",
    "status": "Active",
    "source": "NMC Indian Medical Register",
    "source_url": "https://www.nmc.org.in/information-desk/indian-medical-register/",
    "nmc_doctor_id": 3631,
    "state_medical_council": "Maharashtra Medical Council",
    "registration_date": "10/01/2000",
    "year_info": 2000,
    "qualification": "MBBS",
    "qualification_year": "2000",
    "university": "U.Shivaji"
  },
  "processing_time_ms": 842,
  "credits_used": 3
}

Failure response:

json
{
  "success": false,
  "verification_type": "doctor",
  "verification_data": {
    "is_valid": false,
    "doctor_name": null,
    "registration_id": "9999999999",
    "status": "Not Found",
    "source": "NMC Indian Medical Register",
    "source_url": "https://www.nmc.org.in/information-desk/indian-medical-register/"
  },
  "error": "Doctor registration ID was not found in NMC IMR.",
  "processing_time_ms": 716,
  "credits_used": 0
}
Field Description
successWhether the verification request produced a successful match
verification_typeThe type of verification, here `doctor`
verification_data.is_validBoolean flag your system can use for routing
verification_data.doctor_nameDoctor name from the NMC record
verification_data.registration_idRegistration ID checked
verification_data.statusRecord status such as `Active`, `Removed`, `Restored`, `Not Found`, or `Ambiguous
verification_data.sourceSource used for the lookup
verification_data.source_urlPublic NMC IMR URL
verification_data.nmc_doctor_idNMC doctor ID when available
verification_data.state_medical_councilState Medical Council associated with the record
verification_data.registration_dateRegistration date returned by the source
verification_data.qualificationMedical qualification returned by the source
verification_data.qualification_yearYear of qualification when available
verification_data.universityUniversity listed in the record
processing_time_msTime taken to process the request
credits_usedUsage value returned by the API response

Making Your First API Call


Create an API key in your dashboard and store it in an environment variable. Do not put the key in frontend code, mobile apps, public repositories, screenshots, or client-side logs. Use your backend to call the verification endpoint.

You can create an account at register and use the API docs while testing.

javascript
require("dotenv").config();
const axios = require("axios");

const API_URL = "https://api.theverifico.com/api/v1/verify/doctor";

function normalizeCouncil(value) {
  return value ? value.trim() : undefined;
}

function validateRegistrationId(registrationId) {
  return typeof registrationId === "string" && registrationId.trim().length > 0;
}

async function verifyDoctorRegistration({ registrationId, stateMedicalCouncil, doctorId }) {
  if (!validateRegistrationId(registrationId)) {
    // Stop empty inputs before they enter your provider onboarding workflow.
    return {
      decision: "collect_again",
      reason: "missing_registration_id"
    };
  }

  try {
    const response = await axios.post(
      API_URL,
      {
        registration_id: registrationId.trim(),
        state_medical_council: normalizeCouncil(stateMedicalCouncil)
      },
      {
        headers: {
          "X-API-Key": process.env.THEVERIFICO_API_KEY,
          "Content-Type": "application/json"
        },
        timeout: 10000
      }
    );

    const result = response.data;
    const data = result.verification_data || {};

    if (result.success && data.is_valid && data.status === "Active") {
      return {
        decision: "approve_provider",
        doctor_id: doctorId,
        doctor_name: data.doctor_name,
        registration_id: data.registration_id,
        state_medical_council: data.state_medical_council
      };
    }

    if (data.status === "Ambiguous") {
      // Ask for council details instead of rejecting a potentially valid doctor.
      return {
        decision: "manual_review",
        reason: "ambiguous_registration_id",
        matches: data.matches || []
      };
    }

    return {
      decision: "reject_or_collect_again",
      reason: data.status || "doctor_registration_not_verified"
    };
  } catch (error) {
    if (error.response?.status === 401) {
      return { decision: "internal_fix", reason: "invalid_api_key" };
    }

    if (error.response?.status === 402) {
      return { decision: "pause_verification", reason: "account_limit_reached" };
    }

    if (error.response?.status >= 500) {
      return { decision: "retry_later", reason: "verification_source_unavailable" };
    }

    return {
      decision: "manual_review",
      reason: error.response?.data?.detail || "unknown_error"
    };
  }
}

verifyDoctorRegistration({
  registrationId: "2000010031",
  stateMedicalCouncil: "Maharashtra Medical Council",
  doctorId: "doc_10045"
}).then(console.log);
python
import os
import asyncio
import httpx

API_URL = "https://api.theverifico.com/api/v1/verify/doctor"

def normalize_council(value: str | None) -> str | None:
    return value.strip() if value and value.strip() else None

async def verify_doctor_registration(
    registration_id: str,
    state_medical_council: str | None,
    doctor_id: str
) -> dict:
    if not registration_id or not registration_id.strip():
        # Empty records should be fixed in your form before an external lookup.
        return {
            "decision": "collect_again",
            "reason": "missing_registration_id"
        }

    payload = {
        "registration_id": registration_id.strip(),
        "state_medical_council": normalize_council(state_medical_council)
    }

    headers = {
        "X-API-Key": os.environ["THEVERIFICO_API_KEY"],
        "Content-Type": "application/json"
    }

    async with httpx.AsyncClient(timeout=10.0) as client:
        try:
            response = await client.post(API_URL, json=payload, headers=headers)
            response.raise_for_status()
            result = response.json()
            data = result.get("verification_data") or {}

            if result.get("success") and data.get("is_valid") and data.get("status") == "Active":
                return {
                    "decision": "approve_provider",
                    "doctor_id": doctor_id,
                    "doctor_name": data.get("doctor_name"),
                    "registration_id": data.get("registration_id"),
                    "state_medical_council": data.get("state_medical_council")
                }

            if data.get("status") == "Ambiguous":
                return {
                    "decision": "manual_review",
                    "reason": "ambiguous_registration_id",
                    "matches": data.get("matches", [])
                }

            return {
                "decision": "reject_or_collect_again",
                "reason": data.get("status", "doctor_registration_not_verified")
            }

        except httpx.HTTPStatusError as exc:
            if exc.response.status_code == 401:
                return {"decision": "internal_fix", "reason": "invalid_api_key"}

            if exc.response.status_code == 402:
                return {"decision": "pause_verification", "reason": "account_limit_reached"}

            if exc.response.status_code >= 500:
                return {"decision": "retry_later", "reason": "verification_source_unavailable"}

            return {
                "decision": "manual_review",
                "reason": exc.response.text
            }

async def main():
    result = await verify_doctor_registration(
        registration_id="2000010031",
        state_medical_council="Maharashtra Medical Council",
        doctor_id="doc_10045"
    )
    print(result)

asyncio.run(main())
curl
curl -X POST "https://api.theverifico.com/api/v1/verify/doctor" -H "X-API-Key: $THEVERIFICO_API_KEY" -H "Content-Type: application/json" -d '{"registration_id":"2000010031","state_medical_council":"Maharashtra Medical Council"}'


Frequently Asked Questions

What is the official way to verify a doctor's registration number in India?

Use the NMC Indian Medical Register on the National Medical Commission website. Search by registration number, doctor name, State Medical Council, or year where available.

What details should I check in the NMC record?

Check the doctor name, registration ID, State Medical Council, registration date, qualification, university, and status. If the registration number appears in more than one record, use the State Medical Council to disambiguate.

Can I verify a doctor by name only?

Name search can help when the registration number is missing, but it is weaker than registration-number-based verification. Names can be spelled differently, abbreviated, or shared by multiple doctors.

When should a business use an API instead of the NMC website?

Use an API when doctor verification is part of a repeatable workflow: onboarding, profile activation, hospital empanelment, insurance network checks, periodic review, or trust and safety review.

Does the API replace manual compliance review?

No. The API gives your system structured evidence. Your policy still decides what happens when a record is removed, ambiguous, missing, or inconsistent with submitted documents.

Should I store the full API response?

Store the fields your audit process needs: request timestamp, registration ID, State Medical Council, status, decision, and response reference. Keep personal data access-controlled and define retention rules.

Where do I start?

Create an account at register, generate an API key, and test the endpoint using the API docs.

For one-off checks, use the NMC Indian Medical Register directly. For repeatable healthcare onboarding, connect the Doctor Verification API, create your account at register, and follow the API docs to test the first request.

Share
Anas Nadeem

Written by

Anas Nadeem

Founder

Seeking discomfort. Sailing through life by trying new things, building and breaking out a lot of stuff.