Integration Pattern

Clearinghouse Enrichment

You process millions of claims. Nearly 15% of claims submitted to private payers are denied on first submission, and the top reasons are all preventable. Add validation to your pipeline and turn rejections into clean claims.

Denial rate from a Premier Inc. survey of 516 hospitals across 36 states.

For: Clearinghouses, health information exchanges, claim processing platforms

Payment is available today. Coding edits and filing rules are in preview as they move through the same bar.

Pipeline integration

architecture flow

┌─────────────────┐    ┌──────────────────────────┐    ┌─────────────┐
│   Provider /    │    │   Your Clearinghouse     │    │   Payer     │
│   EHR System    │───►│                          │───►│             │
│                 │    │   ┌────────────────────┐ │    │  Adjudicate │
│   837P / 837I   │    │   │  RCIntel checks      │ │    │             │
│                 │◄───│   │  ├─ Expected payment │ │◄───│   835 ERA   │
│   Rejections    │    │   │  ├─ PTP + MUE edits  │ │    │             │
│   with fix      │    │   │  └─ Filing window    │ │    │             │
│                 │    │   └────────────────────┘ │    │             │
└─────────────────┘    └──────────────────────────┘    └─────────────┘

Batch processing example

Group claims by facility, then resolve payment and coding edits per claim:

python

import httpx
from collections import defaultdict

async def enrich_batch(claims: list[dict], api_key: str):
    """Check claims against payment + coding edits, grouped by facility."""
    results = []

    async with httpx.AsyncClient(
        base_url="https://api.your-domain.com",
        headers={"X-API-Key": api_key},
        timeout=30.0,
    ) as client:
        by_facility = defaultdict(list)
        for claim in claims:
            by_facility[claim["facility_ccn"]].append(claim)

        for ccn, facility_claims in by_facility.items():
            for claim in facility_claims:
                code = claim["cpt_code"]
                pay = (await client.get(
                    f"/v1/codes/{code}/payment",
                    params={"ccn": ccn,
                            "payer": claim.get("payer", "medicare")},
                )).json()
                edits = (await client.get(
                    f"/v1/codes/{code}/ncci"
                )).json()

                errors = validate(claim, edits)
                results.append({
                    "claim_id": claim["id"],
                    "valid": len(errors) == 0,
                    "errors": errors,
                    "expected_payment": pay.get("allowed_amount"),
                })

    return results

def validate(claim: dict, edits: dict) -> list[str]:
    errors = []
    mue = edits.get("mue_limit")
    if mue is not None and claim.get("units", 1) > mue:
        errors.append(f"Units {claim['units']} exceed MUE limit {mue}")
    return errors

Business impact

First-pass acceptance

Catch coding-edit and filing errors before submission

Rejection rate

Fewer rejections means less rework for providers and your ops team

Revenue per claim

Enrichment becomes a premium service to your customers

Speed to payment

Clean claims pay faster — fewer round-trips between provider and payer

Differentiation

Offer validation and enrichment that other clearinghouses don't

Anomaly detection

Compare billed amounts against expected payments to flag outliers

Add validation to your pipeline

Start with a free read-only key for development and testing, or talk to us about high-volume access.

Get an API key Talk to us