Auth57 MCP — CMS-0057-F + CMS-0062-P prior-authorization data for AI agents

      Primer · Model Context Protocol
    

What is an MCP server, and why does your AI agent need one for prior authorization?

The Model Context Protocol (MCP) is an open standard — introduced by Anthropic and now adopted across the AI ecosystem — that lets large language models (LLMs) like Claude, ChatGPT, Cursor, and Zed connect to external tools and live data sources through a single, unified interface. Think of MCP as the USB-C port for AI agents: one spec, any tool, zero glue code.

01 · THE PROBLEM

LLMs hallucinate PA rules

Ask any foundation model "does Texas Medicaid require prior authorization for Ozempic for weight loss?" and you'll get a confident, plausible, and frequently wrong answer. Payer policies change weekly. Training data is stale. Without a verified source, agents invent medical-necessity criteria, cite non-existent rules, and expose providers and health plans to denial risk and compliance exposure.

02 · THE PROTOCOL

MCP = tool calling, standardized

MCP servers expose typed tools (functions the agent can call) and resources (structured data the agent can read) over HTTP or stdio. Any MCP-compatible client — Claude Desktop, Claude Code, Cursor, Zed, Windsurf, or a custom agent built on the Anthropic or OpenAI SDK — can discover and invoke them. One server, every agent.

03 · THE FIX

Ground the agent in verified data

Auth57's MCP server gives your agent native access to CMS-0057-F and CMS-0062-P verified prior-authorization rules across 51 states and 6 programs — Medicaid MCO, Medicare Advantage, commercial, ACA exchange, and more. Every response includes source URLs and human verified-dates. No scraping, no hallucination, no custom integration work.

Why you need an MCP server for prior authorization workflows

If you're building AI-powered utilization management, provider intake automation, payer policy copilots, appeals drafting tools, or clinical decision support — anything that touches prior authorization — you need a trusted data layer. REST APIs work, but they require custom SDKs, auth plumbing, and per-agent integration. MCP collapses that to a single config line. Your agent gets:

Grounded answers — citable payer rules with source URLs, not guesses from pre-training.
51-state coverage — every U.S. state and territory Medicaid program, plus Medicare Advantage, commercial, and exchange plans.
Change monitoring — auth57_diff_policy surfaces rule changes within 24 hours so agents never act on stale policy.
Federal mandate context — gold-card laws, parity rules, and CMS Interoperability and Prior Authorization Final Rule (CMS-0057-F) bypass conditions built into every response.
Zero-integration setup — drop one JSON block into Claude Desktop, Cursor, or any MCP client and your agent is online.

Learn more about the Model Context Protocol spec at modelcontextprotocol.io, or jump straight to the quick-start config below.

Endpoint

https://api.auth57.io/api/mcp

Auth

Every tools/call requires an Auth57 API key passed as Authorization: Bearer <your-auth57-api-key> on the MCP connection. Discovery methods (initialize, tools/list, resources/list) are open. MCP-tier subscribers ($99/mo) get 10,000 tools/calls per 30 days; API-tier subscribers ($299/mo) include MCP with 50,000/mo.

Quick start — Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "auth57": {
      "transport": {
        "type": "http",
        "url": "https://api.auth57.io/api/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_AUTH57_API_KEY"
        }
      }
    }
  }
}

Quick start — Claude Code / Cursor / Zed

Add a .mcp.json to your project root:

{
  "mcpServers": {
    "auth57": {
      "url": "https://api.auth57.io/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_AUTH57_API_KEY"
      }
    }
  }
}

Tools

auth57_pa_strategyauth required

Ranked list of PA pathways for a case — primary (standard PA), federal-protection bypass, gold-card exemption, appeal. Each pathway returns steps, citations, turnaround estimates, and bypass conditions. Use this instead of raw lookup when the agent needs to plan, not just check.

auth57_pa_strategy(state: string, program: enum, drug?: string, service?: string, case_summary?: string)

auth57_explain_ruleauth required

Narrative-ready explanation bundle for a rule: authoritative record, clinical rationale hint, applicable federal mandate context, and citations. Structured data only — the client LLM composes the prose.

auth57_explain_rule(state: string, program: enum, drug?: string, service?: string)

auth57_draft_appealauth required

Structured appeal components — key rebuttal points, cited rule, federal protections, suggested letter structure — for the agent to assemble into prose. Does not return a finished letter; returns the scaffolding with verified citations.

auth57_draft_appeal(state: string, program: enum, denial_reason: string, drug?: string, service?: string, patient_facts?: string)

auth57_diff_policyauth required

Every version change to a rule between two dates: changed_fields, source_url, note, timestamps. Ideal for monitoring agents and "what changed this week" summaries. Backed by pa_rule_history.

auth57_diff_policy(state: string, program: enum, drug?: string, service?: string, from_date: ISO-date, to_date?: ISO-date)

auth57_verify_claimauth required

Fact-check a free-text claim against the verified corpus. Returns the authoritative rule + a verdict hint (supported / refuted / partial / unknown) and guidance for the client LLM to compose the final explanation.

auth57_verify_claim(claim: string, state?: string, program?: enum, drug?: string, service?: string)

auth57_watch_subscribeauth required

Register a watch for (states, programs, optional drug_classes / service_categories). Returns a subscription_id the agent can reference later. Agent polls with auth57_diff_policy.

auth57_watch_subscribe(states: string[], programs: enum[], drug_classes?: string[], service_categories?: string[], label?: string)

Resources

auth57://mandates

Full CMS mandate registry as JSON. Read with resources/read.

auth57://states

Metadata for all 51 states as JSON. Read with resources/read.

Example agent flow — drafting an appeal

User: "My TX Medicaid patient was denied Ozempic for weight loss.
        Help me appeal."

Agent (internal):
  1. auth57_pa_strategy(state="TX", program="medicaid_mco",
                        drug="glp1_weight_loss")
     → pathways: [primary, gold_card, appeal]
        last_verified: 2026-04-02
        source_url: hhs.texas.gov/...

  2. auth57_draft_appeal(state="TX", program="medicaid_mco",
                         drug="glp1_weight_loss",
                         denial_reason="not medically necessary",
                         patient_facts="BMI 38, failed metformin")
     → cited_rule + key_rebuttal_points[] + suggested_structure[]

Agent response: (composes the appeal letter from the scaffolding,
  quoting the verified source_url — no hallucinated policy text.)

Pricing

MCP-only: $99/mo · 10,000 tools/calls per 30 days. Start MCP →
API + MCP bundle: $299/mo · 50,000 tools/calls + full REST access. Start API →

Why Auth57 as the PA data layer for AI

Other AI PA tools (Cohere, Availity, Banjo) automate the workflow around rules. They're only as accurate as their rule data. Auth57 sells the data itself — with source URLs, human verified-dates, and a Watch pipeline that catches changes within 24 hours. If an agent's hallucinating or drifting on stale data, Auth57 anchors it to cited truth.

Registry listings

Auth57 MCP is listed on Anthropic's official MCP registry, Smithery.ai, mcp.so, and Glama. Search "auth57", "prior authorization", or "PA rules".

Spec: modelcontextprotocol.io · Built on @modelcontextprotocol/sdk

Prior authorization data, native to your AI agent.