RCI for EHR & Platform Builders

You’re building healthcare software. Your users — billers, providers, administrators — all need billing knowledge. Instead of building and maintaining billing rule engines yourself, embed RCI.

What RCI does for your product

Replace internal billing logic

You currently maintain…	RCI replaces it with…
Fee schedule lookup tables	`POST /v1/knowledge/payment-calc` — MPFS calculation with GPCI
Payer rules database	L4 layer — timely filing, prior auth, appeal deadlines per payer
Billing form determination logic	L2 layer — CMS-1500 vs UB-04 from facility type
POS code mapping	L3 layer — place of service from care setting + facility
Coding guidance features	`POST /v1/agents/code-research` — AI-powered code research
Denial management rules	`POST /v1/agents/denial-resolution` — AI denial resolution
Medical necessity checking	`POST /v1/agents/medical-necessity` — NCD/LCD validation

Keep your data fresh

CMS updates fee schedules, GPCI values, and coding rules annually. Payers change their rules constantly. RCI handles these updates — you don’t have to.

Three integration methods

1. REST API (server-side)

Direct HTTP calls from your backend. Best for server-side rendering, batch processing, and backend workflows.

import httpx

class RCIClient:
    def __init__(self, api_key: str, base_url: str = "https://api-dev.rcintell.com"):
        self.client = httpx.AsyncClient(
            base_url=base_url,
            headers={"X-API-Key": api_key, "Content-Type": "application/json"},
            timeout=30.0,
        )

    async def resolve(self, ccn: str, cpt: str = None, payer: str = None, care_setting: str = None):
        resp = await self.client.post("/v1/knowledge/resolve", json={
            k: v for k, v in {
                "ccn": ccn, "cpt": cpt, "payer": payer, "care_setting": care_setting,
            }.items() if v is not None
        })
        resp.raise_for_status()
        return resp.json()

    async def payment(self, ccn: str, cpt: str):
        resp = await self.client.post("/v1/knowledge/payment-calc", json={"ccn": ccn, "cpt": cpt})
        resp.raise_for_status()
        return resp.json()

    async def billing_guide(self, ccn: str, cpt: str, payer: str = None):
        body = {"ccn": ccn, "cpt": cpt}
        if payer:
            body["payer"] = payer
        resp = await self.client.post("/v1/knowledge/billing-guide", json=body)
        resp.raise_for_status()
        return resp.json()

    async def code_research(self, query: str, ccn: str = None):
        body = {"query": query}
        if ccn:
            body["ccn"] = ccn
        resp = await self.client.post("/v1/agents/code-research", json=body)
        resp.raise_for_status()
        return resp.json()

interface ResolveParams {
  ccn: string;
  cpt?: string;
  payer?: string;
  careSetting?: string;
}

class RCIClient {
  constructor(private apiKey: string, private baseUrl = "https://api-dev.rcintell.com") {}

  private async request(method: string, path: string, body?: object) {
    const res = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers: { "X-API-Key": this.apiKey, "Content-Type": "application/json" },
      body: body ? JSON.stringify(body) : undefined,
    });
    if (!res.ok) throw new Error(`RCI ${res.status}: ${await res.text()}`);
    return res.json();
  }

  resolve(params: ResolveParams) {
    return this.request("POST", "/v1/knowledge/resolve", {
      ccn: params.ccn,
      cpt: params.cpt,
      payer: params.payer,
      care_setting: params.careSetting,
    });
  }

  payment(ccn: string, cpt: string) {
    return this.request("POST", "/v1/knowledge/payment-calc", { ccn, cpt });
  }

  billingGuide(ccn: string, cpt: string, payer?: string) {
    return this.request("POST", "/v1/knowledge/billing-guide", { ccn, cpt, payer });
  }
}

2. MCP Server (for AI features)

If your product has AI features (copilots, assistants, chatbots), connect them to RCI via the MCP server:

{
  "mcpServers": {
    "rci-knowledge": {
      "type": "http",
      "url": "https://api-dev.rcintell.com/v1/mcp",
      "headers": {
        "X-API-Key": "kp_test_..."
      }
    }
  }
}

Your AI features can then call resolve_knowledge, calculate_payment, research_code, and resolve_denial as tools.

3. Agent callbacks (async jobs only)

Agent endpoints return 202 with a job_id. Poll GET /v1/agents/jobs/{job_id}, or pass callback_url (and callback_secret) on submit. There is no POST /v1/webhooks registry. See Agent callbacks.

curl -X POST https://api-dev.rcintell.com/v1/agents/code-research \
  -H "X-API-Key: kp_test_..." \
  -H "Content-Type: application/json" \
  -d '{
    "query": "CPT for total knee arthroplasty?",
    "callback_url": "https://your-platform.com/webhooks/rci-agent",
    "callback_secret": "whsec_your_shared_secret"
  }'

Where RCI fits in your product

Product type	Integration point	RCI feature
EHR	Order entry	Prior auth check (L4), medical necessity (agent)
EHR	Charge capture	Billing form (L2), POS code (L3), modifiers (L5)
Practice Management	Claims review	Full L1-L6 validation before submission
Billing Platform	Coding workflow	Code research agent, documentation requirements
Billing Platform	AR follow-up	Filing deadlines (L4), denial resolution (agent)
Patient Portal	Cost transparency	Payment estimate (L6) for patient responsibility
Revenue Cycle Analytics	Benchmarking	MPFS expected payment as baseline for payer analysis
Clearinghouse	Claim scrubbing	L1-L4 validation, form/POS/modifier checks
Payer Platform	Adjudication	Coding validation, medical necessity checks

Pricing for platforms

Plan	Requests	Best for
Free	1,000/month	Prototyping and development
Pro	50,000/month	Production with moderate volume
Enterprise	Unlimited	High-volume platforms, custom SLA

See accounts and billing for full details.

Get Started

Who is RCIntel for?

Policies

Knowledge Resolution

AI Agents

MCP Server

Facilities

Integrations

Free Tools

Healthcare Essentials

Platform

RCI for EHR & Platform Builders

What RCI does for your product

Replace internal billing logic

Keep your data fresh

Three integration methods

1. REST API (server-side)

2. MCP Server (for AI features)

3. Agent callbacks (async jobs only)

Where RCI fits in your product

Pricing for platforms

​What RCI does for your product

​Replace internal billing logic

​Keep your data fresh

​Three integration methods

​1. REST API (server-side)

​2. MCP Server (for AI features)

​3. Agent callbacks (async jobs only)

​Where RCI fits in your product

​Pricing for platforms

What RCI does for your product

Replace internal billing logic

Keep your data fresh

Three integration methods

1. REST API (server-side)

2. MCP Server (for AI features)

3. Agent callbacks (async jobs only)

Where RCI fits in your product

Pricing for platforms