> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rcintell.com/llms.txt
> Use this file to discover all available pages before exploring further.

# RCI for Clearinghouses

> Enrich transactions with billing knowledge, catch errors before they reach payers, reduce rejection rates

You process millions of transactions. The industry averages 15-20% denial rates on first submission, and the top reasons are all preventable: wrong billing form, wrong POS code, missing modifier, expired filing deadline, coding errors. Most clearinghouses route transactions. RCI lets you scrub them against billing rules before they hit the payer — turning rejections into clean claims.

## What RCI does for you

### Transaction enrichment

Every claim flowing through your pipeline can be enriched with billing knowledge:

| Check              | What RCI validates                                                        | Rejection prevented                                          |
| ------------------ | ------------------------------------------------------------------------- | ------------------------------------------------------------ |
| **Billing form**   | Is this a CMS-1500 claim from a facility that should be billing on UB-04? | CARC 16 (missing/incomplete information)                     |
| **POS code**       | Does the place of service match the facility type and care setting?       | CARC 182 (procedure code inconsistent with place of service) |
| **Modifiers**      | Are the right modifiers present for this facility/setting combination?    | CARC 4 (procedure code inconsistent with modifier)           |
| **Timely filing**  | Has the payer-specific filing deadline passed?                            | CARC 29 (time limit for filing has expired)                  |
| **Payment system** | Is the claim being routed to the correct fee schedule?                    | Routing errors                                               |
| **TOB code**       | For institutional claims, is the type of bill correct for the facility?   | CARC 16                                                      |

### Real-time validation

Add RCI to your claim scrubbing pipeline:

```
Claim received from provider
    │
    ├─ Parse CCN from claim
    ├─ RCI: GET /v1/knowledge/layers/{ccn}
    │       Returns L1-L4 (no CPT needed for form/POS/payer checks)
    │
    ├─ Validate billing form against L2
    ├─ Validate POS code against L3
    ├─ Validate timely filing against L4
    │
    ├─ If CPT present:
    │   ├─ RCI: POST /v1/knowledge/resolve (full L1-L6)
    │   ├─ Validate modifiers against L3/L5
    │   └─ Calculate expected payment from L6 (for anomaly detection)
    │
    ├─ Pass → Route to payer
    └─ Fail → Return to provider with specific correction needed
```

### Batch processing

For high-volume processing, call the API per-claim or batch by facility (since L1-L4 are the same for all claims from the same facility):

```python theme={null}
import httpx
import asyncio

async def enrich_claims(claims: list[dict], api_key: str):
    """Enrich a batch of claims with knowledge, grouped by facility."""
    facility_cache = {}

    async with httpx.AsyncClient(
        base_url="https://api-dev.rcintell.com",
        headers={"X-API-Key": api_key},
        timeout=30.0,
    ) as client:
        for claim in claims:
            ccn = claim["facility_ccn"]

            if ccn not in facility_cache:
                resp = await client.get(f"/v1/knowledge/layers/{ccn}")
                facility_cache[ccn] = resp.json()

            facility_knowledge = facility_cache[ccn]

            if claim.get("cpt_code"):
                resp = await client.post("/v1/knowledge/resolve", json={
                    "ccn": ccn,
                    "cpt": claim["cpt_code"],
                    "payer": claim.get("payer", "Medicare"),
                })
                claim["knowledge"] = resp.json()
            else:
                claim["knowledge"] = facility_knowledge

            claim["validation_errors"] = validate_against_knowledge(
                claim, claim["knowledge"]
            )

    return claims


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

    for layer in layers:
        layer_name = layer.get("layer", "")

        if layer_name == "l2_facility_type":
            expected_form = layer.get("billing_form")
            if expected_form and claim.get("billing_form") != expected_form:
                errors.append(f"Billing form mismatch: expected {expected_form}")

        if layer_name == "l3_care_setting":
            expected_pos = layer.get("pos_code")
            if expected_pos and str(claim.get("pos_code")) != str(expected_pos):
                errors.append(f"POS code mismatch: expected {expected_pos}")

        if layer_name == "l4_payer":
            filing_limit = layer.get("timely_filing_federal")
            if filing_limit:
                pass  # check claim date_of_service vs today

    return errors
```

## Value for your business

| Metric                         | How RCI improves it                                                                |
| ------------------------------ | ---------------------------------------------------------------------------------- |
| **First-pass acceptance rate** | Catch form, POS, modifier, and filing errors before submission                     |
| **Rejection rate**             | Fewer rejections = less rework for providers and your 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. |

## Integration architecture

```
┌─────────────────┐     ┌──────────────────────┐     ┌─────────────┐
│   Provider /    │     │   Your Clearinghouse  │     │   Payer     │
│   EHR System    │────►│                       │────►│             │
│                 │     │   ┌─────────────────┐ │     │             │
│   837P / 837I   │     │   │  RCI Knowledge  │ │     │   Adjudicate│
│                 │     │   │  Validation     │ │     │             │
│                 │◄────│   │  Enrichment     │ │◄────│   835 ERA   │
│   Rejections    │     │   └─────────────────┘ │     │             │
└─────────────────┘     └──────────────────────┘     └─────────────┘
```

RCI sits inside your pipeline as a validation and enrichment step. You control the integration — RCI provides the knowledge.