How does a 270/271 eligibility API integration work?
Your system sends a 270 eligibility inquiry, either as raw X12 005010X279A1 or as JSON to a clearinghouse API that builds the X12 for you. The clearinghouse routes it to the payer, and a 271 response comes back, under CAQH CORE rules within 20 seconds. Your code then reads the 271’s EB segments: coverage status, service type, co-pay, co-insurance, deductible and out-of-pocket amounts, network and benefit period. It must also handle AAA rejections, which mean the payer could not answer, not that the patient is uninsured.
Getting a 271 back is easy. Reading it correctly is the job
A clearinghouse sandbox will return a 271 on your first afternoon. The trouble shows up with real payers: one answers only for general medical coverage whatever you asked, another lists forty benefits for the same service type, a third carves mental health out to a different company, and a rejection because the member ID had a prefix gets shown to the front desk as “not eligible”.
This page is the engineering view of real-time eligibility as of 13 November 2026: an annotated 270 and 271, how to read EB segments, AAA rejection codes and what to do with each, payer variation, the CAQH CORE timing and availability rules, batch versus real time, caching, Medicare’s HETS, the clearinghouse options with the prices they publish, and the effort a build takes.
We build these integrations as part of our HL7 and EDI integration and systems integration services. Our own practice platform already builds 270s and parses 271s; it is not yet connected to a live clearinghouse, and we say more about that below.
The path of one eligibility check
- Your system collects the patient’s payer, member ID, name and date of birth, the provider’s NPI, the date of service and what kind of service it is.
- It sends a 270 to a clearinghouse, either as X12 text over an API or SFTP, or as JSON to an API that builds the X12 for you.
- The clearinghouse validates it, picks the route to the payer and forwards it. It answers immediately with a 999 rejection if the file is malformed.
- The payer looks up the member and returns a 271 with coverage and benefits, or an AAA segment saying why it cannot.
- Your system parses the 271, stores it, and turns it into something a receptionist can act on: covered, not covered, could not check and why, and what the patient will likely owe.
The HIPAA-mandated format for both transactions is X12 version 005010X279A1. X12 has recommended moving every HIPAA transaction to version 008060, and CMS has been collecting industry input, but as of 13 November 2026 we found no proposed rule that changes the 270/271. A separate CMS proposal (CMS-0062-P) would use FHIR instead of 270/271 for prior authorization only; routine eligibility stays X12.
A 270 request, annotated
Illustrative; the clinic, payer and patient are invented, and the NPI is the standard check-digit example. Segments end with ~ and elements are separated by *.
ISA*00* *00* *ZZ*CLINIC01 *ZZ*CLEARHOUSE *261113*0915*^*00501*000000457*0*T*:~
GS*HS*CLINIC01*CLEARHOUSE*20261113*0915*457*X*005010X279A1~
ST*270*0001*005010X279A1~
BHT*0022*13*REQ457*20261113*0915~
HL*1**20*1~
NM1*PR*2*EXAMPLE HEALTH PLAN*****PI*99999~
HL*2*1*21*1~
NM1*1P*2*LAKE VIEW FAMILY CLINIC*****XX*1234567893~
HL*3*2*22*0~
TRN*1*93175-0001*9877281234~
NM1*IL*1*SAMPLE*ASHA****MI*W123456789~
DMG*D8*19880614~
DTP*291*D8*20261113~
EQ*30~
SE*13*0001~
GE*1*457~
IEA*1*000000457~- ISA and GS are the envelope. ISA is fixed-width (106 characters), ISA15 = T marks a test, and GS08 names the implementation guide.
- Three HL levels, each pointing to its parent: 20 is the information source (the payer), 21 the information receiver (the provider), 22 the subscriber. Get the parent pointers wrong and the payer rejects the whole request.
- TRN is your trace number. The payer echoes it in the 271, and it is how you match a response to the request when many are in flight.
- NM1*IL is the subscriber with the member ID (MI). If a dependent has their own member ID on the card, send them here as the subscriber; the separate dependent level is only for dependents without their own ID.
- EQ*30 asks about general health benefit plan coverage. Ask for a specific service type (98 for an office visit, MH for mental health, 33 for chiropractic) when that is what the visit needs.
A 271 response, annotated
The same request answered. The envelope is omitted; benefits are abridged to the ones a front desk uses most.
ST*271*0001*005010X279A1~
BHT*0022*11*REQ457*20261113*091502~
HL*1**20*1~
NM1*PR*2*EXAMPLE HEALTH PLAN*****PI*99999~
HL*2*1*21*1~
NM1*1P*2*LAKE VIEW FAMILY CLINIC*****XX*1234567893~
HL*3*2*22*0~
TRN*2*93175-0001*9877281234~
NM1*IL*1*SAMPLE*ASHA****MI*W123456789~
DMG*D8*19880614*F~
DTP*346*D8*20260101~
EB*1*IND*30*PR*GOLD PPO 2500~
EB*C*IND*30***23*2500*****Y~
EB*C*IND*30***29*1840*****Y~
EB*G*IND*30***23*6000*****Y~
EB*B*IND*98***27*30*****Y~
EB*A*IND*98*****.4****N~
MSG*OUT OF NETWORK COINSURANCE APPLIES AFTER DEDUCTIBLE~
EB*U**MH~
LS*2120~
NM1*Y2*2*EXAMPLE BEHAVIORAL HEALTH~
PER*IC**TE*8005550100~
LE*2120~
SE*24*0001~How to read it:
- TRN*2 echoes your trace number. DTP*346 is the plan begin date (347 would be the end).
- EB*1 … 30: active coverage for general benefits, on a PPO plan (EB04 = PR) called GOLD PPO 2500.
- EB*C … 23 … 2500: individual deductible of 2,500 per calendar year, in network (EB12 = Y). The next line, with time period 29, says 1,840 of it remains.
- EB*G: out-of-pocket maximum of 6,000 per calendar year.
- EB*B … 98 … 27*30: a co-payment of 30 per visit for an office visit, in network.
- EB*A … 98 … .4 … N: co-insurance of 0.4 (forty percent) for office visits out of network, explained by the MSG line under it. X12 sends percentages as decimals.
- EB*U … MH with the LS/LE loop: mental health is carved out; contact the named organisation for those benefits. The original payer will not tell you more.
Parsing 271 EB segments
| Element | What it holds | Common values | Parsing rule |
|---|---|---|---|
| EB01 | Eligibility or benefit type | 1–5 active (1 active coverage), 6–8 inactive, A co-insurance, B co-payment, C deductible, F limitations, G out of pocket, I non-covered, U contact following entity, V cannot process | Status codes and money codes are different kinds of statement. Never reduce the response to one yes/no from the first EB. |
| EB02 | Coverage level | IND individual, FAM family, and others | Show individual and family deductibles side by side; patients ask about both. |
| EB03 | Service type code | 30 health benefit plan coverage, 1 medical care, 33 chiropractic, 35 dental, 47 hospital, 86 emergency, 88 pharmacy, 98 office visit, AL vision, MH mental health, UC urgent care | Repeats with the ^ separator; one EB can cover several services. Index benefits by service type. |
| EB04, EB05 | Insurance type and plan description | HM HMO, PR PPO, MA and MB Medicare Parts A and B, and others | Display the plan name as sent; patients recognise it. |
| EB06 | Time period | 23 calendar year, 22 service year, 27 visit, 29 remaining, 32 lifetime | “29 remaining” is a balance, not a limit. Pair it with the limit for the same service and level. |
| EB07, EB08 | Amount, percent | Money as a decimal number; percent as a fraction (.2 is twenty percent) | Store money in minor units; never parse percent as a whole number. |
| EB09, EB10 | Quantity qualifier and quantity | VS visits, DY days, and others | Visit limits for therapy and chiropractic live here. |
| EB11 | Authorisation required | Y, N, U (unknown) | Flag Y to the scheduler; U means ask the payer. |
| EB12 | In-plan network | Y in network, N out of network, W not applicable | Says which network the benefit applies to, not whether your provider is in it. Check participation separately. |
Around the EB segments: DTP gives dates (346 and 347 plan begin and end, 356 and 357 eligibility begin and end, 291 a plan date range; a benefit-level DTP overrides the plan dates for that benefit); MSG carries free text that often holds the real condition; LS/LE wraps a related entity such as a carve-out vendor or a primary care provider; HSD gives visit limits per period.
AAA errors: when the payer will not answer
An AAA segment means the payer, or a system in the path, rejected the question. It is never evidence that the patient is uninsured. AAA01 says whether the request was valid, AAA03 gives the reason and AAA04 what to do next.
| AAA03 | Meaning | What your system should do |
|---|---|---|
| 15 | Required application data missing | Ask for more identifiers (member ID, date of birth, full name) and resend. |
| 41 | Authorization/access restrictions | Provider enrolment or credentials problem with that payer; route to billing staff, do not retry. |
| 42 | Unable to respond at current time | Payer system down. Retry with backoff, unless AAA04 is C, N or S, which means the request itself is the problem. |
| 43 | Invalid/missing provider identification | Check the NPI, and whether the payer requires the provider to enrol for eligibility first. |
| 62 | Date of service not within allowable inquiry period | Move the date into the payer’s window. Medicare’s HETS, for example, accepts dates up to four years back and four months ahead. |
| 72 | Invalid/missing subscriber/insured ID | Re-key the member ID from the card; drop prefixes or suffixes the payer does not use. |
| 73 | Invalid/missing subscriber/insured name | Match the spelling and punctuation on the card exactly. |
| 75 | Subscriber/insured not found | Try other identifier combinations, or the dependent as subscriber; then ask the patient. |
| 76 | Duplicate subscriber/insured ID number | Several members matched; add date of birth. |
| 79 | Invalid participant identification | The payer may not support electronic eligibility through this route; do not retry automatically. |
AAA04 values include C (correct and resubmit), N (resubmission not allowed), R (resubmission allowed), W and X (wait 30 or 10 days), and Y (do not resubmit; the payer will respond again). Two other failures look different: a 999 means the X12 itself was invalid and never reached the payer; a TA1 means the envelope was rejected. With JSON clearinghouse APIs these usually arrive as HTTP errors with a vendor error code, which you should map to the same categories.
Payer variation you have to design for
- Service types ignored. Some payers answer every inquiry with general (30) benefits whatever EQ asked; others return different service types than requested, such as mental health under MH, A4, CF or AI. Index by what came back, not what you asked.
- Too much detail. Large commercial plans can return dozens of EB segments for one service type, split by place of service, network and level. Pick by EB03, EB02, EB12 and the benefit date, and show the rest on demand.
- Too little detail. Some Medicaid plans confirm coverage and say nothing about cost; pharmacy (88) often confirms only that a benefit exists.
- Carve-outs. Behavioural health, vision, dental and pharmacy are often run by another company, named in an LS/LE loop or only in MSG text.
- Coordination of benefits. Other-payer information (EB01 = R) may be incomplete or stale. Treat it as a prompt to ask the patient, not as fact.
- Member ID formats. Card prefixes, suffixes for dependents and Medicare’s MBI (not the old SSN-based number) all cause 72 and 75 rejections when keyed wrong.
- Medicare. Medicare eligibility comes from CMS’s HETS system, which takes real-time inquiries only, no batch, usually reached through a clearinghouse or network service vendor.
CAQH CORE response-time and availability rules
The CAQH CORE operating rules set service levels for health plans and clearinghouses. CAQH renamed itself DataSpring, powered by CAQH, in June 2026; the rule documents still carry the CAQH CORE name.
| Requirement | Federally mandated rules (Phase I, 2011) | Eligibility & Benefits Infrastructure Rule vEB.2.0 |
|---|---|---|
| Real-time response | 271 or 999 within 20 seconds | 271 or 999 within 20 seconds; met if 90 percent of responses in a calendar month comply; recommended 4 seconds or less per hop |
| Batch response | Submitted by 9:00 pm Eastern, returned by 7:00 am Eastern the next business day | Same, plus a 999 within one hour of receiving the batch |
| System availability | At least 86 percent per calendar week (up to 24 hours of scheduled downtime) | At least 90 percent per calendar week (up to 17 hours), plus an optional 24 hours per quarter |
Status on 13 November 2026: vEB.2.0 has been recommended for federal adoption by NCVHS and is waiting for an interim final rule from HHS; once published, the industry gets 25 months to comply. Many payers and clearinghouses already work to it voluntarily. Sources: the vEB.2.0 rule and DataSpring’s federal adoption page.
What it means for your code: set the client timeout a little above 20 seconds plus your own network time, never block registration on the answer, show “still checking” rather than an error, and expect payers to be offline for hours at a stretch, mostly overnight and at weekends.
Batch or real time?
| Mode | Use it for | Watch for |
|---|---|---|
| Batch overnight | Tomorrow’s schedule, recall lists, monthly re-verification of recurring patients | Results arrive by morning, not instantly; a rejected file can hold up everything in it. Medicare HETS does not accept batch. |
| Real time at booking | New patients and new insurance, so problems surface days before the visit | Patients often book weeks ahead; coverage can change before the date of service. |
| Real time at check-in | Walk-ins, same-day visits, and anyone whose last check is stale | The front desk is waiting; design for slow and failed responses. |
| Event-driven re-check | New card scanned, plan year starting 1 January, claim denied for eligibility | Easy to forget; most avoidable denials start here. |
Most practices use a mix: a batch run two or three days ahead, and a real-time check at arrival only if the stored answer is older than a set age or the patient brings a new card.
Caching and storage
- Cache by patient, payer, service type and date of service, not by patient alone. An answer for an office visit says little about physical therapy next month.
- Short life. Reuse a 271 for the same day, and re-check when the date of service moves, the plan year turns, or the patient changes card. Clearinghouses charge per check, so a good cache pays for itself, but a stale one causes denials.
- Never cache failures. An AAA 42 or a timeout must not be served as the answer for the rest of the day.
- Keep the raw 271. Store the original response, encrypted, with your parsed summary. When a claim is denied, the raw response shows what the payer actually said on that date.
- It is PHI. Requests and responses contain protected health information: encrypt them at rest and in logs, restrict who can read them, and sign BAAs with the clearinghouse and anyone hosting the data.
Clearinghouse API options and published prices
Prices below are only those the vendor publishes on its own website, read on 13 November 2026, in US dollars. Vendors change them; check the source before you rely on a number. We have no commercial relationship with any of them.
| Option | Published eligibility pricing | Notes | Source |
|---|---|---|---|
| Stedi | Pay as you go, no monthly minimum: $0.30 per check for 1–250 checks a month, $0.15 for 251–3,500, $0.10 for 3,501–10,000, $0.08 above 10,000. Real-time and batch. | JSON and X12 APIs, free sandbox with mock checks, BAA included. A few payers add their own fees, passed through at cost. | stedi.com/pricing |
| Claim.MD | Unlimited plan $120 a month including 1,000 eligibility checks, then $0.02 (prime payers) or $0.10 (non-prime); Small Volume $60 a month including 100, then $0.50; Basic $30 a month, $0.30 per check. No setup fee. | Real-time eligibility through its portal and API; plans bundle claims and ERAs. | claim.md/pricing |
| pVerify | Advanced Eligibility from $125 a month for up to 500 transactions, or from $395 for up to 1,500, on one-year terms; onboarding from $495. | API listed as an integration option; a separate API price is not published. | pverify.com/pricing |
| Availity | No public API price found. | Its Coverages API supports 270/271; plans and rate limits are shown inside the developer portal. | developer.availity.com |
| Large enterprise clearinghouses | No public API price found. | Priced by contract, usually with claims and remittance bundled. Ask for per-check pricing, payer list and response-time statistics in writing. | Vendor sales |
Price is rarely what decides it. Ask each vendor for its payer list for your top twenty payers, whether those payers need provider enrolment for eligibility, median and slowest response times, whether you get the raw 271 as well as the JSON, and what happens to requests during a payer outage.
How an eligibility integration project runs, with effort
Illustrative, not client work: real-time and batch eligibility built into an existing practice system through one clearinghouse API, with parsed results shown at booking and check-in. Effort is in engineer-days.
| Phase | What happens | Typical effort |
|---|---|---|
| Clearinghouse and payers | Top payers listed, clearinghouse chosen, BAA and enrolment started, sandbox access | 2–4 engineer-days |
| Request side | Data capture in the practice system, 270 or JSON request, trace numbers, timeouts and retries | 3–6 engineer-days |
| Response parsing | EB, DTP, MSG and LS/LE parsing into a normalised model, AAA and 999 handling, raw storage | 5–9 engineer-days |
| Front-desk view and caching | Summary per visit type, cache rules, batch run for upcoming appointments | 4–7 engineer-days |
| Payer testing and go-live | Real responses from each top payer reviewed with billing staff, fixes, monitoring | 4–8 engineer-days |
Total: roughly 18–34 engineer-days over four to seven weeks. Waiting for clearinghouse contracts and provider enrolment with payers is often the longest part, and it runs in parallel with the build.
Eligibility integration packages
Typical effort in engineer-days. We confirm a fixed price per phase once we know your system, payers and clearinghouse.
Real-time and batch eligibility
The problem
Your practice system or app needs eligibility checks at booking, overnight and at check-in, through a clearinghouse API.
How we do it
We choose the clearinghouse with you on published price and your payer list, build the request and response handling, parse 271 benefits into a clear front-desk summary, add caching and an overnight batch, and test against your top payers. Typical effort: 18–34 engineer-days.
What you get
- Working checks through your clearinghouse
- 271 parser with AAA and 999 handling
- Front-desk summary and cache rules
- Runbook and monitoring
271 parsing and display
The problem
You already get 271s back, but staff cannot read them and active patients get turned away.
How we do it
We build or fix the parser for EB, DTP, MSG and carve-out loops, map AAA codes to plain-language actions, and design the summary with your billing staff using real responses from your payers. Typical effort: 6–12 engineer-days.
What you get
- Normalised benefit model
- AAA and error mapping
- Summary screen or API
- Test set of real responses
Clearinghouse switch
The problem
Your current clearinghouse is too expensive, too slow, or does not cover your payers.
How we do it
We compare options on your payer list and volumes, build the new connection behind an interface so the practice system does not change, run both side by side for a period and then cut over. Typical effort: 8–15 engineer-days.
What you get
- Vendor comparison on your data
- Adapter layer
- Side-by-side run
- Cutover plan
Eligibility review
The problem
Denials for eligibility are rising and nobody knows whether the checks, the cache or the payer is at fault.
How we do it
We review a sample of checks and their raw 271s against the denials, and report what is misread, missing or stale, with fixes in priority order. Typical effort: 3–6 engineer-days.
What you get
- Findings with examples
- Parser and cache fixes listed
- Payer-specific notes
- Monitoring suggestions
What we have built ourselves, and what we have not
Our own practice platform includes an eligibility module. Here is exactly how far it goes.
Standards, rules and sources behind this guide
Rule versions, statuses and prices were read from the publishers on 13 November 2026.
X12 005010X279A1
The HIPAA-mandated 270/271 version. X12 recommends 008060 for all HIPAA transactions; no rule changing 270/271 has been proposed yet.
CAQH CORE vEB.2.0
20-second real-time responses, next-morning batch, 90 percent weekly availability; recommended for federal adoption, pending an HHS rule.
CMS HETS 270/271
Real-time only, no batch; inquiries accepted up to four years back and four months ahead.
Stedi, Claim.MD, pVerify, Availity
Published prices quoted only where the vendor publishes them, with the source and date.
Normalised benefits plus raw 271
Parsed summary for staff and software; original response kept for audits and appeals.
Tools we use alongside it
- X12 parsers
- Clearinghouse JSON and X12 APIs
- PHP
- Python
- Node.js
- PostgreSQL
Facts, versions and vendor details checked 13 November 2026.
How an eligibility engagement runs
For one practice system and one clearinghouse.
Payers and clearinghouse
Your top payers by volume, clearinghouse shortlist and choice, BAA and enrolment started, sandbox keys.
Requests and parsing
270 or JSON requests from your system, 271 parsing, AAA and error handling, raw storage.
Front desk and batch
Summary per visit type, caching rules, overnight batch for upcoming appointments.
Payer testing and go-live
Real responses from each top payer reviewed with billing staff, fixes, monitoring and handover.
Guides and related pages
Guides
Technologies
Glossary
Where we work
X12 270/271 eligibility: common questions
A 270 is the eligibility inquiry your system sends: who the patient is, which payer, which provider, the date of service and the type of service. A 271 is the payer’s response: whether coverage is active and the benefits that apply, such as co-pay, co-insurance, deductible and out-of-pocket amounts, or an AAA segment explaining why it could not answer.
The CAQH CORE operating rules require a 271, or a 999 error, within 20 seconds of the 270 being submitted. Under the newer vEB.2.0 rule the requirement is met if 90 percent of responses in a calendar month arrive within that time, and each hop in the route should take 4 seconds or less. Most responses are much faster, but your code must handle the slow ones.
It means the payer, or a system on the route, could not answer the inquiry. AAA03 gives the reason, such as 72 for an invalid member ID or 42 for a payer system that is temporarily unavailable, and AAA04 says whether to correct and resubmit. An AAA is never proof that the patient is uninsured.
Published prices on 13 November 2026 ranged from $0.08 to $0.30 per check on Stedi’s pay-as-you-go tiers, and from a $30 monthly plan at $0.30 per check up to a $120 monthly plan including 1,000 checks on Claim.MD. pVerify publishes eligibility plans from $125 a month for up to 500 transactions. Several large clearinghouses do not publish API prices.
Usually both. A batch run two or three days before appointments catches most problems early, and a real-time check at booking or check-in covers new patients, new cards and walk-ins. Medicare’s HETS system accepts real-time inquiries only.
Use 30 for general health benefit plan coverage when you only need to know the patient is covered. When the visit needs specific benefits, ask for that service type, such as 98 for an office visit, MH for mental health or 33 for chiropractic. Some payers answer with general benefits whatever you ask, so parse what comes back.
Not for routine eligibility. X12 005010X279A1 is still the HIPAA-mandated version. X12 has recommended moving HIPAA transactions to version 008060, but no rule has been proposed for the 270/271. A separate CMS proposal would use FHIR APIs instead of 270/271 only for prior authorization.
No. Radiatus OneHealth builds 270 requests and parses 271 responses, but it is not yet connected to a live clearinghouse, so it has not handled real payer traffic. We say this plainly because eligibility parsing only proves itself against real payers, which is why every project we run includes testing with your top payers.
Adding eligibility checks to your system?
Tell us your practice system or app, your top payers, roughly how many checks a month, and whether you already have a clearinghouse. A senior integration engineer will reply with the questions that decide the scope and a typical effort range.






Compliance-first delivery