Provider Verification API — NPI, PECOS & LEIE in One Call

Updated June 9, 2026 · VBC Risk Analytics

Provider verification is the process of confirming that a healthcare provider's credentials — NPI status, taxonomy, Medicare enrollment, and exclusion status — are valid before onboarding, billing, or adding them to a network directory. Done manually, it means opening three separate government portals for every provider. Done via API, it is a single REST call that returns all four data points in under 500 milliseconds. This guide covers what provider verification requires, what the API returns, and how to build a verification pipeline for real-time and batch workloads.

What provider verification covers

Complete provider verification spans data from multiple sources. The NPI Registry API automates the primary data elements; some elements still require other sources:

What the API returns per provider

A single findbyNPIId call returns everything needed for the NPI, PECOS, and LEIE steps of verification:

curl -X GET   'https://restapi.npidataservices.com/api/v1/findbyNPIId?NPIId=1053500652'   -H 'ApiKey: YOUR_API_KEY'

# Key verification fields in the response:
{
  "npi": 1053500652,
  "status": "success",          // NPI is active
  "taxonomy": [{
    "taxonomy_code": "251E00000X",
    "taxonomy_desc": "Agencies: Home Health",
    "prim_taxonomy_switch": "Y"
  }],
  "location": [{
    "addr_city": "PASADENA",
    "addr_state": "CA",
    "addr_post_cd": "911012869"
  }],
  "entity_type": [{
    "in_pecos": "Y",            // enrolled in Medicare
    "in_leie": "N"              // not on OIG exclusion list
  }],
  "medicare_enrlmt": [{
    "enrlmt_id": "O20080407000727",
    "pac_id": "4284711805",
    "provider_type_dec": "PART A PROVIDER - HOME HEALTH AGENCY"
  }]
}

Real-time provider verification pipeline (Python)

This example verifies a single provider at the point of intake or onboarding, returning a structured verification result:

import requests

API_KEY  = "YOUR_API_KEY"
BASE_URL = "https://restapi.npidataservices.com/api/v1/findbyNPIId"

def verify_provider(npi):
    r = requests.get(BASE_URL,
                     params={"NPIId": npi},
                     headers={"ApiKey": API_KEY},
                     timeout=5)

    if r.status_code == 404:
        return {"npi": npi, "status": "INVALID", "reason": "NPI not found in registry"}

    r.raise_for_status()
    d = r.json()

    entity  = (d.get("entity_type")    or [{}])[0]
    enrlmt  = (d.get("medicare_enrlmt") or [{}])[0]
    tax     = (d.get("taxonomy")        or [{}])[0]
    loc     = (d.get("location")        or [{}])[0]

    flags = []
    if entity.get("in_leie") == "Y":
        flags.append("OIG_LEIE_EXCLUDED")
    if entity.get("in_pecos") != "Y":
        flags.append("NOT_PECOS_ENROLLED")

    return {
        "npi":           npi,
        "status":        "FLAGGED" if flags else "VERIFIED",
        "flags":         flags,
        "taxonomy":      tax.get("taxonomy_desc", ""),
        "state":         loc.get("addr_state", ""),
        "in_pecos":      entity.get("in_pecos"),
        "in_leie":       entity.get("in_leie"),
        "enrlmt_id":     enrlmt.get("enrlmt_id", ""),
        "pac_id":        enrlmt.get("pac_id", ""),
    }

# Real-time use (e.g. provider intake form)
result = verify_provider("1053500652")
print(result)
# {"npi": "1053500652", "status": "VERIFIED", "flags": [], "taxonomy": "Agencies: Home Health", ...}

Batch verification for roster screening

For monthly re-verification or large roster checks, loop over your provider list and write results to a report:

import time, csv

roster = ["1053500652", "1184713042", "1023374782"]
results = []

for npi in roster:
    results.append(verify_provider(npi))
    time.sleep(0.1)   # pace within your monthly quota

flagged = [r for r in results if r["status"] == "FLAGGED"]
print(f"{len(flagged)} provider(s) require review")

with open("verification_report.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=results[0].keys())
    writer.writeheader()
    writer.writerows(results)

Real-time vs. batch verification

Compliance drivers for provider verification

Provider verification is not optional for most organizations billing federal programs:

• OIG compliance guidance. OIG recommends screening all employees, contractors, and providers against the LEIE monthly. Billing Medicare or Medicaid with an excluded provider triggers Civil Monetary Penalties — up to $20,000 per item or service billed, plus up to three times the amount claimed, plus exclusion from federal programs (penalty amounts subject to annual inflation adjustment).
• NCQA and URAC credentialing standards. Both require primary source verification of NPI status, taxonomy, and enrollment at initial credentialing and re-credentialing (every 2–3 years).
• CMS No Surprises Act. Health plans must keep provider directories accurate and update them within 2 business days of a change — requiring a verification mechanism that can be triggered on change events.
• Payer enrollment requirements. Payers require active NPI and PECOS enrollment before credentialing a provider into a network.

Why not use the free NPPES API for provider verification

The free NPPES API at npiregistry.cms.hhs.gov confirms NPI status and returns taxonomy and address. It does not return:

• Medicare PECOS enrollment status, enrollment ID, or PAC ID
• OIG LEIE exclusion flag

To verify all four elements from free government sources, you need to query NPPES, the PECOS enrollment dataset, and the OIG LEIE separately — and maintain the join logic yourself. The NPI Registry API returns all four in a single call. See the full comparison in NPPES API vs NPI Registry API.

Related guides

• Provider Credentialing Automation — full credentialing pipeline with PASS/FLAGGED report generation
• OIG Exclusion Screening API — monthly LEIE screening automation and compliance workflows
• PECOS API — Medicare enrollment lookup: enrollment ID, PAC ID, provider type
• LEIE API — OIG exclusion flag returned in every NPI lookup
• NPI Bulk Lookup API — batch verification across a full provider roster
• NPPES API vs NPI Registry API — why the free API is not sufficient for verification workflows
• Provider Onboarding Automation — onboarding pipeline that starts with the same one-call verification check
• Medicare Enrollment Verification — pre-claim PECOS enrollment check for billing and RCM teams
• Healthcare Provider Data API — full enrichment field reference for provider data workflows

Frequently asked questions

What is a provider verification API?
A REST service that confirms a provider's NPI status, taxonomy, Medicare PECOS enrollment, and OIG LEIE exclusion status in a single call — replacing manual lookups across three government portals.

What data does provider verification require?
NPI active status, primary taxonomy, practice address, Medicare PECOS enrollment status, and OIG LEIE exclusion flag. State licensure, DEA, and malpractice history require separate primary source verification.

How often should providers be re-verified?
OIG recommends monthly LEIE screening. NCQA/URAC require full re-credentialing every 2–3 years. Directories should re-verify at least quarterly. All three cadences are supported on Starter and Pro plans.

Can I verify providers in real time?
Yes — findbyNPIId responds in under 500ms for real-time intake and point-of-care use. For bulk roster checks, use a batch loop with 100–200ms pacing.