One connected network forHealth Claims

NHCX brings India’s healthcare ecosystem together with standardised, interoperable claim data — enabling seamless, transparent and efficient exchange across systems.

Building the digital rails for health claims

Watch now
NHCX sessions

What NHCX guarantees

  • Fewer data queries
  • Greater data precision
  • Faster claim processing
  • Scalability
34insurers and TPAs live on NHCX
as of 21 Jul 2024
~300hospitals onboarding to send claims
as of 21 Jul 2024
5claim use cases on one protocol
eligibility · pre-auth · claim · payment notice · communication
1integration for every payer
the exchange routes by participant code

Why does this benefit

Powering businesses of all sizes. Run your business on a reliable platform that adapts your needs.

Standardisation
One standard for every claim

Every claim speaks the same language

NHCX uses FHIR-based standards and internationally accepted coding practices, so provider and payer systems can exchange health information in a common, machine-readable format — without losing its meaning across systems.

Explore documentation →
  • One common structureHealth information follows a consistent FHIR-based format.
  • Zero ambiguityStandardised codes preserve the meaning of clinical information.
  • Works across systemsDifferent technology stacks exchange the same information seamlessly.
Structured data
Send data, not documents

Data a system can read, not a page to re-type

Diagnoses, procedures, drugs and bill lines travel as coded values — priced and checked automatically instead of opened and read.

  • Coded at source
  • Nothing lost in transit
  • Signed and audit-ready
Automation & AI assistance
More accuracy, less resistance

Fewer queries, faster decisions

Validated claims let payer engines price routine cases straight through, and let hospitals catch gaps before a claim ever leaves.

  • Straight-through pricing
  • Checks before submission
  • Insight across claims

How NHCX works

Instead of converting structured hospital data into PDFs and images and sending them manually, NHCX enables providers and payers to exchange digitised, machine-readable health information.

View developer docs
Provider
District hospital
Multi-speciality chain
Nursing home
Diagnostic centre
NHCX
Payer
Insurance company
TPA
State health agency
Government scheme

How a typical flow looks like

From the hospital’s HMIS to a decision, and back again

01 · Hospital HMIS
Structured at source

The discharge summary, bill lines and codes leave the HMIS as a signed FHIR R4 bundle. No PDFs, no re-typing.

02 · In transit
Schema-checked and signed

Validated against the specification and signed on both sides, leaving an immutable trail.

03 · NHCX
Route and deliver

The exchange identifies the payer and delivers the claim. One integration, every payer.

04 · Payer engine
Auto-adjudicated

Policy active, member verified. Package rate matched. Duplicate and abuse checks clear.

05 · The return leg
Back to the provider

The decision travels the same path in reverse and lands in the HMIS — a round trip, not a one-way pipe.

How a typical flow looks like

From the hospital’s HMIS to a decision, and back again

  1. 01 · Hospital HMIS
    Structured at source

    The discharge summary, bill lines and codes leave the HMIS as a signed FHIR R4 bundle. No PDFs, no re-typing.

  2. 02 · In transit
    Schema-checked and signed

    Validated against the specification and signed on both sides, leaving an immutable trail.

  3. 03 · NHCX
    Route and deliver

    The exchange identifies the payer and delivers the claim. One integration, every payer.

  4. 04 · Payer engine
    Auto-adjudicated

    Policy active, member verified. Package rate matched. Duplicate and abuse checks clear.

  5. 05 · The return leg
    Back to the provider

    The decision travels the same path in reverse and lands in the HMIS — a round trip, not a one-way pipe.

How to onboard

Four steps from registration to production

  1. 01

    Register on the ABDM sandbox

    Fill in the sandbox registration form and you can start building. ABHA verification is not required in the sandbox — you only need it for production, where beneficiaries are authenticated for real.

    Sandbox registration
  2. 02

    Integrate and test the APIs

    Build against the HCX sandbox: coverage eligibility, pre-auth, claim, payment notice and communication, each with its on_ callback. Use the Postman collections and the DevTools console to exercise every flow.

    HCX sandbox documents
  3. 03

    Get sandbox certification

    Complete the functional and security test cases for your role. The affiliate sandbox may ask for additional security review (STQC or CERT-In) before it issues the certificates.

    Test cases
  4. 04

    Apply for production

    Share the functional and security certificates. NHCX assigns your role in production, provisions credentials and registers you as a participant — then you go live.

    Apply for sandbox access here
Integration supportWrite to hcx.integration@nha.gov.in or integration.support@nha.gov.in. A standing call for integrators and partners is held on the 22nd of every month.
Facility registryHospitals register their facility in the ABDM Health Facility Registry first — facility.abdm.gov.in, queries to facility@nha.gov.in.

Understand NHCX

A national exchange for health-claim data, run by the National Health Authority under ABDM

The National Health Claims Exchange is the digital gateway between the people who deliver care and the people who pay for it. A hospital submits a claim once, as coded FHIR data; the exchange checks and signs it, finds the payer, and delivers it. The decision comes back the same way. It began as the Health Claims Platform (HCP) and was renamed NHCX on the industry’s suggestion; its specifications were developed in the open with insurers, TPAs and state health agencies.

Who takes part

  • ProvidersHospitals, nursing homes, diagnostic centres and clinics — and the HMIS or TMS vendors that build for them.
  • PayersInsurance companies, TPAs, state health agencies and government schemes such as PM-JAY.
  • Sponsors and regulatorsScheme planners with payer-equivalent access; IRDAI and auditors with aggregate, anonymised views.
  • BeneficiariesPatients, authenticated through ABHA in production (not required in the sandbox), whose consent governs what an ISNP or app may see.

What moves over it

  • Coverage eligibility/coverageeligibility/checkIs this person covered for this treatment, today?
  • Pre-authorisation/preauth/submitApprove a package and amount before admission.
  • Claim/claim/submitThe discharge bundle: diagnosis, procedures, bill lines.
  • Payment notice/paymentnotice/requestSettlement advice, from payer to provider.
  • Communication/communication/requestQueries and supporting documents, both ways.

Every request has an on_ callback, and every message is a signed, encrypted envelope (JWE) around an HL7 FHIR R4 bundle. Read the protocol in the documentation →

Why it matters

  • Structured, not scannedClaims travel as coded data rather than PDFs and images, so payers can auto-adjudicate routine cases and both sides see fewer queries.
  • Lower cost and timeAutomation cuts processing cost and turnaround, reduces manual error and gives the data quality that fraud control and analytics need.
  • Records stay with the hospitalClinical and financial records remain in hospital systems; claim data flows natively into billing and accounts, simplifying audits and reconciliation.
  • Open and non-repudiableOpen APIs, digital signatures on every event, an audit log every participant can query, and a public registry of who is on the exchange.

See what’s happening
inside the tool

Build and validate FHIR bundles visually, with guided fields and instant FHIR output.

Open the FHIR builder →

Every actor in the real network, simulated: a regulator, a government scheme, insurers, TPAs and hospitals that answer your calls the way production will.

Open the simulator →

One static binary — no JVM, no Docker — that signs, encrypts and routes every message, and tells you exactly what is left before you go live.

Get the gateway →

A guided path with a check after every chapter, so a new integrator knows what to build first and why.

Start the learning path →

Point it at a claim from your HMIS and it maps, fixes and validates the bundle against the specification — explaining each change.

Ask the assistant in the documentation →

NHCX developer integration

Send data, not the document

Your hospital system already captures the clinical data a claim needs. NHCX moves that data as structured information instead of converting it into PDFs, images or scanned attachments.

Learn more in the doc →
Preserve clinical detail

Diagnoses, procedures, drugs and bill lines travel as coded values, so nothing is lost in translation between the hospital and the payer.

Learn more in the doc →
Improve claim accuracy

Bundles are validated against the specification before they leave, so incomplete claims are caught at source instead of coming back as queries.

Learn more in the doc →
Enable automation

Machine-readable claims let payer rules engines price routine cases straight through, and let hospitals reconcile settlements automatically.

Learn more in the doc →

Build in the sandbox. Certify once. Go live.

Free to test and certify — for hospitals, insurers, TPAs, government schemes and solution vendors.

Get sandbox access

Specifications and policies

The documents the exchange runs on

Technical specifications

Sandbox, code and this site

Questions and answers

Onboarding
Who should onboard to the sandbox?

Any hospital, insurer, TPA, government scheme or software vendor building health-claim exchange capability. The sandbox exists so each participant can test its own components against the communication standards and get certified before touching production.

Read chapter 10.01 in the documentation →
What happens after I submit the application?

Applications are verified against the details in the form — a semi-manual step, so expect review latency rather than instant provisioning. Duplicate requests from one participant, participants not registered with any registry, TSPs without a valid website and spam are filtered out. Approved participants are added to the sandbox and issued credentials; follow your application on the Status page.

Read chapter 10.01 in the documentation →
Which registry ID do I use?

Providers use the HFR ID generated during ABDM integration. Payers and TPAs use the IRDAI (or respective authority) ID with leading zeros stripped — 0123 is passed as 123. End-user applications may use their client ID. An entity can hold several participant IDs, one per linked HFR ID.

Read chapter 10.01 in the documentation →
What are the role and registry codes, and do they differ between sandbox and production?

They are the same in both. Roles: PROVIDER 10001, PAYER 10002, AGENCY_TPA 10003, EUA 10009. Registries: HFR/EUA 10001, PAYER/TPA 10004. Note that 10001 means PROVIDER as a role and HFR/EUA as a registry — different enums in different fields. Wrong mapping causes access issues, rejections or misrouting.

Read chapter 11.03 in the documentation →
Can I test without a real payer or provider partner?

Yes. The sandbox provides a dummy payer, participant 1000003538@hcx, for insurance plan, coverage eligibility, pre-auth, claim, payment notice and communication. You drive its answer yourself — Approve, Reject or Query — through a control endpoint that does not exist in production, so remove it from your code before go-live.

Read chapter 10.02 in the documentation →
Tokens and access
How do I get a session token, and how long does it last?

Exchange the client_id and client_secret issued at onboarding for a bearer token with an OAuth 2.0 client-credentials call to /get/session. The token lives 1200 seconds (20 minutes): cache it, refresh it well inside that window and never log it. Sandbox tokens do not work against production and vice versa.

Read chapter 03.02 in the documentation →
Why do I get 401 Unauthorized?

Three usual causes: the token was sent without the Bearer prefix; it has expired — “Sender is not authorized to execute the operation” is the expiry message, so renew via the session API; or it was minted for the other environment. On a 401 discard the cached token, mint a new one and replay once; a second 401 means the credentials themselves are wrong.

Read chapter 03.02 in the documentation →
Encryption
How is the payload protected on the wire?

Every request body is a JWE in compact serialization: RSA-OAEP-256 wraps the content key with the recipient’s public certificate and A256GCM encrypts the FHIR bundle. The x-hcx-* routing headers sit in the protected header, so the gateway routes without reading clinical content — the payload is unreadable even to NHCX.

Read chapter 08.01 in the documentation →
Where does the recipient’s certificate come from, and do I sign the payload as well?

Fetch it from the registry with /fetch/certs and cache it for 24 hours. No separate signature is needed: JWE’s authenticated encryption (AEAD) already protects the integrity of the ciphertext and the protected header. Rotate your own encryption key yearly and report any compromise at once.

Read chapter 03.05 in the documentation →
Callbacks
Is any transaction synchronous?

No. The gateway never returns a business decision on the same connection. A submission is acknowledged with HTTP 202 and the answer arrives later as a separate inbound call to your on_ endpoint — /preauth/submit is answered on /preauth/on_submit. Every participant is therefore also an HTTP server.

Read chapter 04.01 in the documentation →
What must my callback endpoint return?

HTTP 202 Accepted with the acceptance body, within 30 seconds. Anything else — a 200, a malformed body, an adjudication holding the socket — is treated as an error: the gateway retries the same message up to five times and then deletes the correlation ID. Acknowledge first, adjudicate after, and be idempotent on x-hcx-correlation_id.

Read chapter 08.03 in the documentation →
My callback never arrives. What do I check?

In order: the callback URL uses a domain name, not an IP address or port; the server is India-based; the NHCX NAT addresses 3.109.99.210, 13.126.152.0 and 13.200.129.223 are whitelisted; the firewall is not dropping them; and the request is not being misrouted inside your own gateway or load balancer.

Read chapter 11.03 in the documentation →
What is the v1/error API, and do I have to implement it?

Yes, every integrator must. It is the sender-side endpoint that receives reject details when a message never reached its recipient or the recipient failed to handle it. Without it a request that died at the gateway looks, from the hospital desk, identical to one still under review.

Read chapter 08.03 in the documentation →
Correlation and headers
What is the difference between api_call_id, request_id and correlation_id?

All three are 36-character UUIDs. x-hcx-api_call_id is new on every single call; x-hcx-request_id is new per request payload; x-hcx-correlation_id is constant for the whole conversation and is what responders copy back, so persist it against your case before you post. After five failed deliveries the correlation ID is dead — start a fresh cycle with a new one.

Read chapter 04.01 in the documentation →
Which timestamp format does x-hcx-timestamp take?

The published sources disagree: the PMJAY handbook shows an IST ISO-8601 value (2026-03-19T11:46:34+05:30) and warns that other zones fail validation, while the integrator FAQ gives a zero-UTC form (2024-05-20T11:29:27.358Z). Validate against the environment you are integrating with rather than assuming; the documentation records both.

Read chapter 08.02 in the documentation →
Which recipient code do I put in the header?

The registry participant code, namespaced as code@hcx. For a payer take the processingID from the get/policies response — not the PayerID field, which is one of the most common integration mistakes. Your own code goes in x-hcx-sender_code.

Read chapter 08.02 in the documentation →
Error codes
What is the difference between NHCX-* and PAYR-* error codes?

NHCX-* codes are raised by the exchange gateway — the headers, registration or transport are wrong and the payer never saw the request. PAYR-* codes come from the payer side, either the bridge that validates FHIR or the adjudication engine. PAYR numbers are reused across sheets with different meanings, so match on the description string and log both.

Read chapter 09.03 in the documentation →
What does NHCX-1006 “Duplicate request” mean?

A message with the same correlation ID already exists in the gateway. Correlation IDs are unique per request cycle: reuse one — including after a failed cycle — and the gateway rejects it. Mint a new UUID and resubmit.

Read chapter 09.03 in the documentation →
Certification and go-live
What does certification actually get me?

A successful-completion certificate from the sandbox, valid for a configured period, issued after your functional and security test results are reviewed. That certificate is what the production onboarding review asks for; depending on policy the sandbox may also require STQC or CERT-IN review.

Read chapter 10.02 in the documentation →
What is tested at sandbox exit?

A fixed use-case list — 13 for providers (registry lookups, session, eligibility, insurance plan, pre-auth, communication, claim, search, payment-notice acknowledgement, task, status) and 15 for payers. Every payload must validate against the NRCeS profiles, responses must carry the right correlation and receiver codes, and rejections use a ProtocolResponse.

Read chapter 10.02 in the documentation →
What changes when I go live?

The gateway base URL, the credentials, the certificates you encrypt against (re-fetch from production) and the counterparty: the dummy payer, its control endpoints and the test provider and policy IDs must be removed. Bundles, headers and encryption stay the same. PMJAY–NHCX is a separate track with extra scheme configuration.

Read chapter 10.02 in the documentation →