Tutorial · Prior authorization

Prior authorization automation with AI

Prior authorization is a document sport: eligibility, payer rules, clinical evidence, forms and status checks. Automate the packet and the follow-up, not the medical judgment.

Short answer. Start with eligibility and payer-specific rules, extract the request into a structured record, assemble a packet with page-level evidence, submit through the channel the payer accepts, and keep a clinician in the loop for denials, missing evidence and high-cost requests.

Map the workflow before you prompt

Prior authorization is a state machine, not one model call. It starts with eligibility and ends with a decision, an appeal or a cancellation. The useful automation boundary is the packet: gathering evidence, putting it in the payer's format and keeping the status current. A clinician keeps the medical necessity decision.

Write the states down before choosing a model: draft, evidence_missing, ready_for_review, submitted, pended, approved, denied, appealed, cancelled. Every transition needs an actor, timestamp and reason.

Eligibility and payer rules

Check eligibility before assembling anything. You need the member ID, plan and product, requested service codes, diagnosis, place of service, and the ordering and rendering provider NPIs. An out-of-network or non-covered request is a paperwork exercise until those facts are resolved.

Payer rules break naive automation. The same service can need different documents from different plans, and the rule can change before the service date. Store rules as versioned records with payer, plan, code range, site of care, required fields, required attachments, source URL, effective date and last-verified date. Retrieve the rule at request time and show the source. Do not ask a model to remember policy from training data.

Payer portals have terms of use; use an API, clearinghouse or documented bulk channel, and record the legal basis for each access path.

Extract the request and the evidence

Packets mix a structured form with unstructured notes. A vision model can read a scan, but the output must be a typed record, not a paragraph. Give it a schema, a null policy and the page image, then validate the result.

import json, os
from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY", base_url="https://api.plugsky.com/v1")
image_url = os.environ["PAGE_IMAGE_URL"]
schema = {
    "member_id": "string", "service_codes": ["CPT or HCPCS"],
    "diagnosis_codes": ["ICD-10-CM"], "ordering_npi": "string",
    "requested_start": "YYYY-MM-DD", "requested_units": "number",
    "evidence": [{"field": "string", "page": "number", "quote": "string"}],
}
response = client.chat.completions.create(
    model="plugsky-parse",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Extract the request. Use null for missing values. "
         "Copy every quote from the page. Do not infer a diagnosis or code. Return JSON."},
        {"role": "user", "content": [
            {"type": "text", "text": json.dumps({"schema": schema})},
            {"type": "image_url", "image_url": {"url": image_url}},
        ]},
    ],
)
record = json.loads(response.choices[0].message.content)
assert record["member_id"] and record["evidence"] and all(e["page"] > 0 for e in record["evidence"])

Keep the page image and verify each quote appears on the cited page. Treat a missing required field as evidence_missing, never as a value to guess. Send one page per request.

Assemble and submit

A good packet has a cover sheet, the payer's form, a letter of medical necessity when required, the notes that support each field, and prior-treatment history. Deduplicate documents, number every page, and keep an evidence map from field to page. Redact what the payer does not need, but never redact the evidence the review depends on.

ChannelUse it whenOperational note
X12 278Payer or clearinghouse supports 278 request/responseMap to the companion guide; keep the acknowledgement
Da Vinci PASPayer exposes a FHIR Claim/$submit endpointJSON bundle; pends handled by subscription or inquiry
Payer portalNo API exists and the terms permit portal useHuman confirms; browser automation is brittle
Fax or mailThe payer requires itKeep the fax confirmation and follow up

CMS-0057-F requires impacted payers to offer a Prior Authorization API from 1 January 2027, with 72-hour expedited and seven-day standard decisions. HHS allows enforcement discretion for all-FHIR implementations without X12 278, but payer readiness varies. Record each payer's supported channel and version.

Status and resubmission

A submitted request is not finished. Payers can approve, deny, partially approve or pend for more information. Pended requests need a timer, an owner and a follow-up path. The Da Vinci PAS guide expects pended authorizations to remain queryable for at least six months after the anticipated service completion, and supports subscriptions plus a Claim inquiry.

  • Record the acknowledgement: payer reference, timestamp, channel, payload hash and the person who released it.
  • Start the clock: use the payer's current timeframe and the request's urgency. Escalate before the deadline.
  • Handle partial approvals: map approved units and dates back to the order and flag the gap.
  • Never auto-resubmit a denial: denials need a reason-code and clinical review, and often different evidence.

Human gates and audit

The model can draft, extract, summarize and check completeness. It should not make the medical necessity determination, sign the attestation or decide an appeal.

  • Clinical gate: a clinician confirms the diagnosis, service and supporting evidence before release.
  • Exception gate: missing documents, conflicting dates, denials, out-of-network or high-cost cases go to a specialist.
  • Urgency gate: expedited requests get a separate queue and a shorter timer.
  • Change gate: payer rule, form and code changes are reviewed and versioned before live use.

Audit request ID, actor, action, timestamp, model and prompt version, document hash, reviewer decision and final payload. Retain originals. This is an engineering guide, not legal or clinical advice. HIPAA, state law and payer contracts impose obligations a model cannot satisfy; a business associate agreement, minimum-necessary review and counsel review are separate workstreams.

ROI and evaluation

Do not start with a percentage. Count the touches: eligibility checks, packets, pages reviewed, submissions, status calls and appeals. Then measure the change.

touches = eligibility + packets + status_calls + appeals
hours_saved = touches * (minutes_before - minutes_after) / 60
net_value = hours_saved * loaded_hourly_cost - run_cost
payback_months = implementation_cost / max(net_value, 1)

Track field accuracy, packet completeness, first-pass approval, denial reasons, rework, time to decision by urgency and human correction rate. Run shadow mode first: let the system draft while humans do the real work, compare, then remove the duplicate step.

FAQ

What can AI automate in prior authorization?

Eligibility lookups, payer-rule retrieval, form and note extraction, packet assembly, completeness checks, submission routing, status tracking and audit logging. Medical necessity decisions and appeals stay with a clinician.

Does prior authorization automation need HIPAA review?

No API is compliant by itself. HIPAA obligations depend on your role, the data, your agreements and your controls. A business associate agreement, minimum-necessary review, access controls, audit logs and counsel review are separate requirements.

Should I submit through X12 278 or FHIR?

Use the channel the payer currently supports. X12 278 is the established HIPAA transaction; Da Vinci PAS uses FHIR Claim/$submit and maps to 278. CMS-0057-F requires impacted payers to offer a Prior Authorization API from 1 January 2027, but readiness varies.

How should the system handle a denial?

Route it to a clinician or appeals specialist with the denial reason, the submitted packet and the payer's appeal instructions. Do not auto-resubmit. A denial may need different evidence, a different code or a peer-to-peer review.

How do I measure ROI?

Count touches before and after, multiply by measured minutes saved, and subtract model, storage, integration and review costs. Track first-pass approval and rework alongside labor savings.

Sources: the CMS-0057-F fact sheet (decision timeframes and the 2027 API requirement), the HL7 Da Vinci PAS implementation guide (Claim/$submit, pends and inquiry) and the X12 278 transaction description. All checked 20 November 2026. Reviewed 20 November 2026. Payer rules, state requirements and contracts change; confirm them before production use. This page is not legal, clinical or compliance advice.