Integration Pattern

Clearinghouse Enrichment

You process millions of claims. The industry averages 15–20% denial rates on first submission, and the top reasons are all preventable. Add knowledge-based validation to your pipeline and turn rejections into clean claims.

For: Clearinghouses, health information exchanges, claim processing platforms

Pipeline integration

architecture flow

┌─────────────────┐    ┌──────────────────────────┐    ┌─────────────┐
│   Provider /    │    │   Your Clearinghouse      │    │   Payer     │
│   EHR System    │───►│                            │───►│             │
│                 │    │   ┌──────────────────────┐ │    │  Adjudicate │
│   837P / 837I   │    │   │  RCI Knowledge       │ │    │             │
│                 │    │   │  ┌─ Validate form    │ │    │             │
│                 │◄───│   │  ├─ Validate POS     │ │◄───│   835 ERA   │
│   Rejections    │    │   │  ├─ Check modifiers  │ │    │             │
│   with fix      │    │   │  ├─ Check filing     │ │    │             │
│                 │    │   │  └─ Estimate payment │ │    │             │
└─────────────────┘    │   └──────────────────────┘ │    └─────────────┘
                       └──────────────────────────┘

Batch processing example

Group claims by facility to cache L1–L4 (same for all claims from the same CCN), then resolve L5–L6 per claim:

python

import httpx
import asyncio
from collections import defaultdict

async def enrich_batch(claims: list[dict], api_key: str):
    """Enrich claims with RCI knowledge, grouped by facility."""
    facility_cache: dict[str, dict] = {}
    results = []

    async with httpx.AsyncClient(
        base_url="https://api.rci.health",
        headers={"X-API-Key": api_key},
        timeout=30.0,
    ) as client:
        # Group by facility for efficient caching
        by_facility = defaultdict(list)
        for claim in claims:
            by_facility[claim["facility_ccn"]].append(claim)

        for ccn, facility_claims in by_facility.items():
            # Cache L1-L4 per facility
            if ccn not in facility_cache:
                resp = await client.get(f"/v1/knowledge/layers/{ccn}")
                facility_cache[ccn] = resp.json()

            # Resolve L5-L6 per claim
            for claim in facility_claims:
                if claim.get("cpt_code"):
                    resp = await client.post("/v1/knowledge/resolve", json={
                        "ccn": ccn,
                        "cpt": claim["cpt_code"],
                        "payer": claim.get("payer", "Medicare"),
                    })
                    knowledge = resp.json()
                else:
                    knowledge = facility_cache[ccn]

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

    return results

def validate(claim: dict, knowledge: dict) -> list[str]:
    errors = []
    layers = knowledge.get("layers", [])

    for layer in layers:
        name = layer.get("layer", "")
        data = layer.get("data", {})

        if name == "l2_facility_type":
            expected = data.get("billing_form")
            if expected and claim.get("billing_form") != expected:
                errors.append(f"Billing form: expected {expected}")

        if name == "l3_care_setting":
            expected = data.get("pos_code")
            if expected and str(claim.get("pos_code")) != str(expected):
                errors.append(f"POS code: expected {expected}")

        if name == "l4_payer":
            # Check timely filing against claim date
            pass

    return errors

Business impact

First-pass acceptance

Catch form, POS, modifier, and filing errors before submission

Rejection rate

Fewer rejections = less rework for providers and your ops team

Revenue per claim

Knowledge enrichment becomes a premium service to your customers

Speed to payment

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

Differentiation

Most clearinghouses route transactions. You route knowledge-enriched transactions.

Anomaly detection

Compare billed amounts against expected payments to flag outliers

Add knowledge to your pipeline

Start validating claims against billing rules at scale. Free tier supports development and testing.

Get your API key Clearinghouse docs