Building an AI Agent That Reads X12 EDI: 270/271 Eligibility, 278 Prior Auth, and 835 Remittance

Part of our complete guide to agentic AI in RCM.

Nearly 95% of all provider claims in the United States are submitted electronically using the X12 837 format. Change Healthcare alone processes over 15 billion transactions per year, touching one in three patient records. The global healthcare EDI market reached $4.47 billion in 2024 and is projected to hit $7.11 billion by 2029. Yet for most engineering teams, X12 EDI remains an opaque binary-era format — pipe-delimited, deeply nested, and hostile to modern tooling.

This guide shows you how to build an AI agent that reads, writes, and acts on X12 EDI transactions. We will dissect the message format, parse it in Python, wrap parsed data as LangChain tools, map X12 to FHIR resources, and wire the entire pipeline into a production architecture that connects your EHR to payer systems through a clearinghouse.

Anatomy of an X12 EDI Message

Every X12 message follows a strict envelope hierarchy. Understanding this structure is the first step to parsing or generating EDI programmatically.

The Four-Layer Envelope

ISA/IEA — Interchange Control Envelope: The outermost wrapper. The ISA header is always exactly 106 characters and defines the sender, receiver, control number, and — critically — the delimiter characters used throughout the message. The first three characters after ISA define the element separator (typically *), and the last character before the segment terminator defines the sub-element separator (typically :). The segment terminator itself (typically ~) ends every segment in the file.

GS/GE — Functional Group: Groups related transaction sets by type. A single interchange can contain multiple functional groups — for example, one group of 270 eligibility requests and another of 837 claims. The GS01 element identifies the functional group type: HS for eligibility (270/271), HP for claims (837), HR for remittance (835).

ST/SE — Transaction Set: A single business document. The ST01 element specifies the transaction type number (270, 271, 835, 837, etc.), and ST02 provides a unique control number for tracking.

Segments, Loops, and Elements: Within a transaction set, data is organized into segments (like NM1 for name, DTP for date, SV1 for service). Each segment contains elements separated by *. Elements can contain sub-elements separated by :. Segments are grouped into hierarchical loops (HL segments) that establish parent-child relationships — for example, payer → provider → subscriber → patient.

Annotated 270 Eligibility Request

Here is a real X12 270 eligibility inquiry with every segment explained:

ISA*00*          *00*          *ZZ*SENDER_ID      *ZZ*RECEIVER_ID    *260316*1200*^*00501*000000001*0*P*:~
GS*HS*SENDER_ID*RECEIVER_ID*20260316*1200*1*X*005010X279A1~
ST*270*0001*005010X279A1~
BHT*0022*13*REQ20260316*20260316*1319~
HL*1**20*1~
NM1*PR*2*AETNA*****PI*12345~
HL*2*1*21*1~
NM1*1P*2*CITY GENERAL HOSPITAL*****XX*1234567890~
HL*3*2*22*0~
TRN*1*TRACE001*9SENDER_ID~
NM1*IL*1*SMITH*JOHN****MI*ABC123456789~
DMG*D8*19800115*M~
DTP*291*D8*20260316~
EQ*30~
SE*14*0001~
GE*1*1~
IEA*1*000000001~

Breaking this down segment by segment:

• ISA — Interchange header: identifies sender/receiver, date (260316 = March 16, 2026), version (00501), and sets delimiters: * for elements, : for sub-elements, ~ for segment terminator
• GS*HS — Functional group for Health Care Eligibility (HS). References the 005010X279A1 implementation guide
• ST*270 — Transaction Set 270: Eligibility, Coverage, or Benefit Inquiry
• BHT*0022*13 — Begin Hierarchical Transaction. Purpose code 13 = Request. Includes a reference ID and timestamp
• HL*1**20*1 — Hierarchy Level 1, code 20 = Information Source (the payer). Child code 1 means children follow
• NM1*PR*2*AETNA — Payer name. PR = Payer, 2 = Organization, PI = Payer Identification with ID 12345
• HL*2*1*21*1 — Hierarchy Level 2, parent is HL1, code 21 = Information Receiver (the provider)
• NM1*1P*2*CITY GENERAL HOSPITAL — Provider name with NPI (XX*1234567890)
• HL*3*2*22*0 — Hierarchy Level 3, parent is HL2, code 22 = Subscriber. Child code 0 = no children
• TRN*1*TRACE001 — Trace number for correlating the 271 response back to this request
• NM1*IL*1*SMITH*JOHN — Subscriber (Insured/Subscriber). Member ID: ABC123456789
• DMG*D8*19800115*M — Demographics: DOB January 15, 1980, Male
• DTP*291*D8*20260316 — Service date: March 16, 2026
• EQ*30 — Eligibility inquiry for service type 30 (Health Benefit Plan Coverage)
• SE*14*0001 — Transaction set trailer: 14 segments, control number 0001

The Six Essential X12 Transaction Sets

While the X12 standard defines over 300 transaction sets, healthcare operations concentrate on six core types. Understanding when each is used is essential for building an agent that automates revenue cycle workflows.

The 270/271 pair handles real-time eligibility verification, which is the most frequent EDI transaction — many practices run hundreds daily. The 835 remittance is the most data-dense, often containing thousands of claim-line adjustments in a single file. The 837 is the revenue engine, carrying the actual billing data that generates reimbursement. For a side-by-side view of the two claim files, see our 835 vs 837 comparison. Our real-time eligibility verification work covers 270/271, payer APIs and governed portal checks.

Related Reading

For more insights, explore our guides on X12 EDI for Healthcare Developers: 835, 837, 270/271 and FHIR in Modern Healthcare.

You may also find value in EHR Software Development Guide and Building a Healthtech App.

Parsing X12 in Python

Several Python libraries handle X12 parsing. The most practical options:

• x12-edi-tools — Modern library with parser, generator, and built-in eligibility checker. Supports 270/271 out of the box
• TigerShark — Mature X12 parser with strong 835 support. Handles 270/271 and 835 with typed segment models
• edi-835-parser — Focused library for remittance advice. Extracts payments, adjustments, and service lines from 835 files
• pyx12 — Reference implementation for X12 validation. Useful for conformance testing against implementation guides

Here is a general-purpose X12 parser class that works with any transaction set:

from dataclasses import dataclass, field
from typing import Optional
import re


@dataclass
class X12Segment:
    segment_id: str
    elements: list[str] = field(default_factory=list)
    raw: str = ""

    def get(self, index: int, default: str = "") -> str:
        """Get element by 1-based index (matching X12 convention)."""
        try:
            return self.elements[index - 1] if index > 0 else self.segment_id
        except IndexError:
            return default

    def sub_elements(self, index: int, separator: str = ":") -> list[str]:
        """Split a composite element into sub-elements."""
        val = self.get(index)
        return val.split(separator) if val else []


class X12Parser:
    """Parse any X12 EDI file into structured segments."""

    def __init__(self, raw_edi: str):
        self.raw = raw_edi.strip()
        self.element_sep = "*"
        self.sub_element_sep = ":"
        self.segment_term = "~"
        self.segments: list[X12Segment] = []
        self._detect_delimiters()
        self._parse()

    def _detect_delimiters(self):
        """ISA segment is always 106 chars. Delimiters are positional."""
        if not self.raw.startswith("ISA"):
            raise ValueError("X12 file must start with ISA segment")
        self.element_sep = self.raw[3]
        self.sub_element_sep = self.raw[104]
        self.segment_term = self.raw[105]

    def _parse(self):
        """Split raw EDI into Segment objects."""
        raw_segments = self.raw.split(self.segment_term)
        for raw_seg in raw_segments:
            raw_seg = raw_seg.strip()
            if not raw_seg:
                continue
            parts = raw_seg.split(self.element_sep)
            seg = X12Segment(
                segment_id=parts[0],
                elements=parts[1:] if len(parts) > 1 else [],
                raw=raw_seg,
            )
            self.segments.append(seg)

    def transaction_type(self) -> Optional[str]:
        """Return the ST01 transaction set identifier."""
        for seg in self.segments:
            if seg.segment_id == "ST":
                return seg.get(1)
        return None

    def find_segments(self, segment_id: str) -> list[X12Segment]:
        """Find all segments matching a given ID."""
        return [s for s in self.segments if s.segment_id == segment_id]

    def get_patient_name(self) -> dict:
        """Extract patient/subscriber name from NM1*IL segment."""
        for seg in self.find_segments("NM1"):
            if seg.get(1) == "IL":
                return {
                    "last_name": seg.get(3),
                    "first_name": seg.get(4),
                    "member_id": seg.get(9),
                }
        return {}

    def get_payer(self) -> dict:
        """Extract payer information from NM1*PR segment."""
        for seg in self.find_segments("NM1"):
            if seg.get(1) == "PR":
                return {
                    "name": seg.get(3),
                    "payer_id": seg.get(9),
                }
        return {}

    def to_dict(self) -> dict:
        """Convert parsed X12 to a dictionary for agent consumption."""
        return {
            "transaction_type": self.transaction_type(),
            "patient": self.get_patient_name(),
            "payer": self.get_payer(),
            "segment_count": len(self.segments),
            "segments": [
                {"id": s.segment_id, "elements": s.elements}
                for s in self.segments
            ],
        }


# Usage
edi_content = open("eligibility_270.edi").read()
parser = X12Parser(edi_content)
print(f"Transaction: {parser.transaction_type()}")
print(f"Patient: {parser.get_patient_name()}")
print(f"Payer: {parser.get_payer()}")

For 835 remittance parsing, which requires deeper claim-line extraction:

class RemittanceParser(X12Parser):
    """Specialized parser for 835 remittance advice."""

    def get_payments(self) -> list[dict]:
        """Extract payment details from CLP segments."""
        payments = []
        current_claim = None

        for seg in self.segments:
            if seg.segment_id == "CLP":
                if current_claim:
                    payments.append(current_claim)
                current_claim = {
                    "claim_id": seg.get(1),
                    "status_code": seg.get(2),
                    "charge_amount": float(seg.get(3, "0")),
                    "paid_amount": float(seg.get(4, "0")),
                    "patient_responsibility": float(seg.get(5, "0")),
                    "adjustments": [],
                    "service_lines": [],
                }
            elif seg.segment_id == "CAS" and current_claim:
                current_claim["adjustments"].append({
                    "group_code": seg.get(1),
                    "reason_code": seg.get(2),
                    "amount": float(seg.get(3, "0")),
                })
            elif seg.segment_id == "SVC" and current_claim:
                current_claim["service_lines"].append({
                    "procedure": seg.get(1),
                    "charge_amount": float(seg.get(2, "0")),
                    "paid_amount": float(seg.get(3, "0")),
                    "units": seg.get(5, "1"),
                })

        if current_claim:
            payments.append(current_claim)
        return payments

    def total_paid(self) -> float:
        """Calculate total payment amount across all claims."""
        return sum(p["paid_amount"] for p in self.get_payments())

Wrapping X12 Parsers as AI Agent Tools

The real power emerges when you wrap X12 operations as AI agent tools. Using LangChain or LangGraph, each tool becomes a function the agent can invoke based on natural language instructions — "check if John Smith is covered by Aetna" or "how much did we get paid on claim 12345."

from langchain_core.tools import tool
from x12_parser import X12Parser, RemittanceParser
import httpx


CLEARINGHOUSE_URL = "https://api.clearinghouse.example.com"
CLEARINGHOUSE_API_KEY = "your-api-key"


@tool
def check_eligibility(patient_id: str, payer_id: str) -> dict:
    """Check patient insurance eligibility by sending X12 270
    and parsing the 271 response. Returns coverage status,
    copay, deductible, and out-of-pocket maximum."""

    # 1. Build X12 270 request
    edi_270 = build_270_request(patient_id, payer_id)

    # 2. Submit to clearinghouse
    response = httpx.post(
        f"{CLEARINGHOUSE_URL}/eligibility",
        content=edi_270,
        headers={
            "Content-Type": "application/edi-x12",
            "Authorization": f"Bearer {CLEARINGHOUSE_API_KEY}",
        },
    )

    # 3. Parse 271 response
    parser = X12Parser(response.text)
    benefits = extract_benefits(parser)

    return {
        "patient_id": patient_id,
        "payer": parser.get_payer(),
        "covered": benefits.get("active", False),
        "copay": benefits.get("copay"),
        "deductible": benefits.get("deductible"),
        "deductible_remaining": benefits.get("deductible_remaining"),
        "oop_max": benefits.get("out_of_pocket_max"),
    }


@tool
def get_claim_status(claim_id: str) -> dict:
    """Check the adjudication status of a submitted claim
    using X12 276/277 transaction pair."""

    edi_276 = build_276_request(claim_id)

    response = httpx.post(
        f"{CLEARINGHOUSE_URL}/claim-status",
        content=edi_276,
        headers={
            "Content-Type": "application/edi-x12",
            "Authorization": f"Bearer {CLEARINGHOUSE_API_KEY}",
        },
    )

    parser = X12Parser(response.text)
    status_seg = parser.find_segments("STC")

    return {
        "claim_id": claim_id,
        "category_code": status_seg[0].get(1) if status_seg else None,
        "status": map_status_code(status_seg[0].get(1)) if status_seg else "Unknown",
        "effective_date": extract_status_date(parser),
        "total_charge": extract_charge_amount(parser),
    }


@tool
def parse_remittance(edi_file_path: str) -> dict:
    """Parse an X12 835 remittance advice file and extract
    all payment details, adjustments, and denial reasons."""

    with open(edi_file_path) as f:
        raw_edi = f.read()

    parser = RemittanceParser(raw_edi)
    payments = parser.get_payments()

    return {
        "total_claims": len(payments),
        "total_paid": parser.total_paid(),
        "total_charged": sum(p["charge_amount"] for p in payments),
        "denied_claims": [
            p for p in payments if p["status_code"] == "4"
        ],
        "adjustments_summary": summarize_adjustments(payments),
        "claims": payments,
    }


@tool
def submit_prior_auth(
    patient_id: str,
    procedure_code: str,
    diagnosis_code: str,
    payer_id: str,
) -> dict:
    """Submit a prior authorization request using X12 278.
    Returns authorization number and status."""

    edi_278 = build_278_request(
        patient_id, procedure_code, diagnosis_code, payer_id
    )

    response = httpx.post(
        f"{CLEARINGHOUSE_URL}/prior-auth",
        content=edi_278,
        headers={
            "Content-Type": "application/edi-x12",
            "Authorization": f"Bearer {CLEARINGHOUSE_API_KEY}",
        },
    )

    parser = X12Parser(response.text)
    auth_info = extract_auth_response(parser)

    return {
        "patient_id": patient_id,
        "procedure": procedure_code,
        "auth_number": auth_info.get("auth_number"),
        "status": auth_info.get("status"),
        "effective_date": auth_info.get("effective_date"),
        "expiration_date": auth_info.get("expiration_date"),
    }

These tools can be registered with a LangChain agent or a clinical decision support system that responds to natural language queries from clinicians and billing staff:

from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

llm = ChatOpenAI(model="gpt-4o", temperature=0)

agent = create_react_agent(
    llm,
    tools=[check_eligibility, get_claim_status,
           parse_remittance, submit_prior_auth],
    prompt="You are a healthcare revenue cycle agent. Use the "
           "available tools to check eligibility, track claims, "
           "parse remittance files, and submit prior authorizations. "
           "Always verify eligibility before submitting prior auth."
)

# Natural language interaction
result = agent.invoke({
    "messages": [{"role": "user",
                  "content": "Check if patient P12345 is covered "
                  "by Aetna, then submit a prior auth for CPT 27447 "
                  "(knee replacement) with diagnosis M17.11"}]
})

X12 to FHIR Resource Mapping

In a modern interoperable healthcare architecture, X12 transactions should be mapped to their FHIR equivalents. This allows your EHR to work with structured FHIR resources while the agent handles the X12 translation layer when communicating with payers and clearinghouses.

The X12 to FHIR conversion is not one-to-one — a single 835 remittance file may produce dozens of ClaimResponse resources plus a PaymentReconciliation that ties them together. The HIPAA-to-FHIR mapping specifications from organizations like Da Vinci and CARIN Alliance define the canonical mappings for each segment.

Here is how the agent converts a parsed 271 eligibility response to a FHIR CoverageEligibilityResponse:

def x12_271_to_fhir(parser: X12Parser) -> dict:
    """Convert parsed X12 271 to FHIR CoverageEligibilityResponse."""
    patient = parser.get_patient_name()
    payer = parser.get_payer()
    eb_segments = parser.find_segments("EB")

    benefits = []
    for eb in eb_segments:
        benefit = {
            "type": {"coding": [{"code": map_benefit_type(eb.get(1))}]},
            "description": map_service_type(eb.get(3)),
        }
        # EB*B = Active Coverage, EB*6 = Inactive
        if eb.get(1) == "B":
            benefit["network"] = {"coding": [{"code": eb.get(6, "Y")}]}
            if eb.get(7):  # Amount
                benefit["benefit"] = [{
                    "type": {"coding": [{"code": "copay"}]},
                    "allowedMoney": {
                        "value": float(eb.get(7)),
                        "currency": "USD"
                    }
                }]
        benefits.append(benefit)

    return {
        "resourceType": "CoverageEligibilityResponse",
        "status": "active",
        "patient": {"reference": f"Patient/{patient.get('member_id', '')}"},
        "insurer": {
            "reference": f"Organization/{payer.get('payer_id', '')}",
            "display": payer.get("name", "")
        },
        "insurance": [{
            "coverage": {"reference": f"Coverage/{patient.get('member_id', '')}"},
            "inforce": any(eb.get(1) == "1" for eb in eb_segments),
            "item": benefits
        }],
        "purpose": ["benefits"],
        "created": "2026-03-16",
    }

Production Architecture: EHR to Payer Pipeline

In production, the AI agent sits between your EHR and the clearinghouse, translating between FHIR (internal) and X12 (external). Here is the end-to-end data flow for an eligibility check:

Step 1: Patient Arrives — FHIR Trigger

When a patient checks in, the EHR fires a FHIR Subscription notification or the scheduling system triggers the agent. The agent reads the Patient resource and associated Coverage resource via FHIR API to gather demographics, member ID, and payer information.

Step 2: Agent Builds X12 270

The agent maps FHIR Coverage fields to X12 270 segments: Coverage.subscriberId becomes NM1*IL element 9, Coverage.payor resolves to NM1*PR, and the service date from the Appointment resource maps to DTP*291.

Step 3: Clearinghouse Submission

The X12 270 is sent to the clearinghouse via SFTP (batch) or REST API (real-time). Major clearinghouses like Availity, Change Healthcare, and Waystar accept both modes. Real-time eligibility responses typically return within 2–15 seconds.

Step 4: Parse X12 271 Response

The agent receives the 271 response, parses EB (Eligibility/Benefit) segments to extract active coverage status, copay amounts, deductible balances, out-of-pocket maximums, and any coverage limitations or exclusions.

Step 5: Update FHIR Server

The parsed data is written back as a FHIR CoverageEligibilityResponse resource. The front desk staff sees real-time coverage information in the EHR without manual payer portal lookups. If coverage is inactive, the agent can automatically flag the encounter for financial counseling.

Security: X12 Contains PHI

X12 EDI files carry some of the most sensitive patient data in healthcare — Social Security numbers in REF*SY segments, dates of birth in DMG, diagnosis codes in HI, and detailed treatment histories across claim lines. Any system that processes X12 must meet HIPAA technical safeguard requirements:

• BAA with clearinghouse: A signed Business Associate Agreement is legally required before exchanging any X12 transactions containing PHI. This covers Availity, Change Healthcare, Trizetto, Waystar, and any other trading partner
• Encryption in transit: SFTP (SSH File Transfer Protocol) for batch transmissions, TLS 1.2+ for API-based real-time connections. Never send X12 over unencrypted FTP or HTTP
• Encryption at rest: X12 files stored on disk or in databases must be encrypted using AES-256. This includes raw EDI files, parsed data, and any cached eligibility responses
• Audit logging: Log every X12 transaction with timestamp, user/system ID, transaction type, and patient identifier. HIPAA requires 6-year retention of audit logs. Your agent should log every tool invocation with the transaction trace number (TRN segment)
• Minimum necessary: The agent should only request and store the specific eligibility or claim data needed for the current workflow. Avoid caching full 835 remittance files with thousands of patient records longer than necessary
• Access controls: Role-based access to X12 parsing tools. Billing staff can run eligibility checks; clinical staff should not see remittance payment details unless required for their role

What Is Changing: January 2027 FHIR Prior Auth Mandate

The CMS Interoperability and Prior Authorization final rule (CMS-0057-F) requires payers to implement FHIR-based prior authorization APIs by January 1, 2027. This is the first time FHIR will serve as a standalone replacement for an X12 HIPAA transaction (278). However, X12 837 claims and 835 remittance will remain the standard for years to come — building agent tools that handle both X12 and FHIR ensures your architecture is future-proof.

The X12 008060 standard guides were also released in late 2025, replacing the long-standing 005010 version. While federal HIPAA adoption of 008060 is still pending rulemaking, organizations should begin planning their migration path. An agent-based architecture makes this transition significantly easier — you update the X12 builder/parser tools once, and every workflow that depends on them inherits the new format automatically.

Building With Nirmitee

At Nirmitee, we build healthcare software that bridges legacy EDI infrastructure with modern FHIR-based architectures. Our engineering teams have deep experience with X12 transaction processing, clearinghouse integrations, and AI-driven revenue cycle automation. If you are building an EHR, practice management system, or revenue cycle platform that needs to process X12 transactions at scale, we can help you design and implement the agent architecture described in this guide.

Ready to deploy AI agents in your healthcare workflows? Explore our Agentic AI for Healthcare services to see what autonomous automation can do. We also offer specialized Healthcare Interoperability Solutions services. Talk to our team to get started.

Frequently Asked Questions

What is the difference between X12 and HL7 in healthcare?

X12 EDI handles financial and administrative transactions (claims, eligibility, payments) between providers and payers. HL7 v2/FHIR handles clinical data exchange (lab results, patient records, clinical documents) between healthcare systems. An EHR typically uses both: HL7/FHIR for clinical workflows and X12 for billing workflows.

Can I send X12 transactions directly to a payer without a clearinghouse?

Technically yes — some large payers accept direct connections. Practically, clearinghouses provide validation, routing to 1,000+ payers, rejection handling, and compliance checks. For most organizations, the clearinghouse layer saves significant engineering effort.

How do I handle X12 rejections and errors?

The 999 Implementation Acknowledgment transaction reports syntax errors in submitted X12 files. The TA1 Interchange Acknowledgment reports envelope-level errors. Your agent should parse both and implement automatic correction for common issues (invalid dates, missing required segments) before resubmission.

Is the X12 standard going away?

Not soon. While FHIR will replace the 278 prior authorization transaction by January 2027 (CMS mandate), X12 837 claims and 835 remittance have no FHIR replacement timeline. The industry processes over 30 billion X12 transactions annually — migration will take a decade or more. Building for both formats is the pragmatic approach.

Related reading

• EDI 277 claim status automation with AI agents
• how AI agents are transforming care delivery