What Is Submitted To The Payer Requesting Reimbursement? Simply Explained

What’s the paperwork that actually lands on a payer’s desk when a provider asks for money?

You’ve probably seen a stack of forms, a flurry of codes, maybe even a glossy PDF that says “Claim.” But most of us never stop to wonder what exactly gets sent, why it looks the way it does, and how a tiny mistake can stall a payment for weeks.

Let’s pull back the curtain and walk through the whole “what is submitted to the payer requesting reimbursement” process—from the raw data a clinic gathers to the final electronic file that a health‑insurance company processes No workaround needed..

What Is Submitted to the Payer

In plain English, the “submission” is a claim. It’s a structured packet of information that tells the insurer: We delivered these services, these are the codes that describe them, the patient’s responsibility is X, and we expect Y dollars.

Think of it like an invoice, but with a lot more rules. Instead of just “$200 for a haircut,” a medical claim must include the patient’s identifier, the provider’s NPI, dates of service, diagnosis codes (ICD‑10‑CM), procedure codes (CPT/HCPCS), modifiers, units, charges, and a ton of other data points that let the payer apply the contract rules you’ve agreed to.

The Core Pieces

All of that lives inside a 837 transaction when you’re sending electronically, or a paper CMS-1500 form if you’re still faxing. The 837 is the industry‑standard EDI (Electronic Data Interchange) format that insurers’ clearinghouses love.

Why It Matters

If you get the claim right, the payer’s automated rules spit out a payment in a few days. Miss a single field, and you’re staring at a denial, a request for information (RFI), or—worst case—an audit.

Real‑world impact? Practically speaking, a small community clinic I consulted for was losing roughly $30,000 a month because they kept sending claims with the wrong place‑of‑service code. The payer kept flagging them as “out‑of‑network,” and the clinic had to chase every single one. Once they corrected the POS, the same volume of claims cleared in under a week.

Understanding exactly what you’re sending isn’t just academic; it’s the difference between cash flow that keeps the lights on and a mountain of unpaid invoices.

How It Works

Below is the step‑by‑step flow most providers follow, from the moment a patient walks in to the moment the payer deposits the check (or ACH).

1. Capture the Encounter

• The front desk pulls the patient’s insurance card, verifies eligibility, and records the member ID.
• The clinician documents the visit in the EMR, selecting diagnosis and procedure codes as they go.

2. Generate the Claim Draft

• The EMR or practice‑management system pulls the data into a claim draft.
• At this stage you’ll see a screen that lists each line item: diagnosis (e.g., M54.5 – low back pain), CPT (e.g., 99213 – office visit, established patient), units, and the charge you entered.

3. Validate the Data

• Edit checks run automatically: “Is the diagnosis code valid for the service date?” “Do the modifiers match the CPT rules?”
• Some systems flag mismatches (e.g., a modifier “‑59” on a preventive service that the payer disallows).

4. Convert to 837 (or CMS‑1500)

• For electronic submissions, the software translates the claim into an ANSI X12 837P (professional) or 837I (institutional) file.
• For paper, the system prints a CMS‑1500 that mirrors the same fields.

5. Transmit to the Clearinghouse

• Most practices don’t send directly to the insurer; they use a clearinghouse that batches, validates, and routes the claim.
• The clearinghouse returns an acknowledgment (997) confirming receipt and flagging any syntax errors.

6. Payer Processing

• The insurer’s claims engine applies the contract: fee schedule, deductibles, co‑pays, prior authorizations, etc.
• If everything lines up, you get an Electronic Remittance Advice (ERA, 835) that shows the allowed amount, patient responsibility, and any adjustments.

7. Reconcile & Post

• The practice posts the payment, updates patient balances, and files the ERA for audit purposes.

That’s the high‑level map. Let’s dig into a few of the trickier pieces No workaround needed..

Diagnosis and Procedure Coding

Diagnosis codes tell the payer why the service was needed. Without a valid diagnosis, the claim is treated as “not medically necessary” and gets denied.

Procedure codes are the “what.” Each CPT or HCPCS code has its own set of accepted diagnoses (the “DX‑to‑CPT mapping”). Here's one way to look at it: CPT 99214 can’t be billed with a diagnosis of “Z00.00 – general adult medical exam” if the payer requires a problem‑oriented visit.

Pro tip: Keep a reference table for your most common services. It saves time and reduces errors.

Modifiers: The Fine‑Print

Modifiers are the little suffixes that change a code’s meaning. They’re optional, but ignoring them can cost you.

• ‑25 – Significant, separately identifiable evaluation and management service. Use when you bill a routine visit plus a distinct procedure.
• ‑59 – Distinct procedural service. Tells the payer two services on the same day aren’t duplicates.
• ‑TC – Technical component only (often used for radiology).

If you slap the wrong modifier on, the payer might bundle the service, slash the payment, or send an RFI.

Place of Service (POS) Codes

POS is a single‑digit number (01‑99) that says where the service happened Still holds up..

• 11 – Office
• 21 – Inpatient Hospital
• 02 – Telehealth (non‑audio)

During the COVID‑19 surge, many payers broadened POS 02 for virtual visits. After the pandemic, some rolled it back. That’s why you’ll still see “POS 02 denied” popping up in claim logs.

The 837 File Structure

If you ever peeked at an 837, you’ll notice it’s a series of segments—each line starts with a three‑letter identifier (e.g., ISA, GS, NM1, CLM).

• ISA/GS – Interchange and functional group headers (think envelope).
• NM1 – Name information (patient, provider).
• CLM – Claim information (total charge, claim ID).
• HI – Diagnosis codes.
• SV1 – Service line details (CPT, units, charge).

You don’t need to hand‑code these, but knowing they exist helps when a clearinghouse returns a “segment error” and you have to hunt down the offending line Simple as that..

Common Mistakes / What Most People Get Wrong

1. Skipping Eligibility Checks – Assuming the patient’s coverage is active. In practice, a “coverage lapse” shows up as a denial with code A3 Surprisingly effective..

2. Mismatched Diagnosis‑to‑Procedure – Billing a preventive service with a symptom‑based diagnosis. The payer’s edit will reject it Most people skip this — try not to..

3. Forgotten Modifiers – Not adding ‑25 when you have a separate E/M service. The claim gets bundled and you lose the extra reimbursement The details matter here..

4. Wrong POS Code – Using “01” for a telehealth visit. The payer may apply the office fee schedule, which is often lower or outright denied.

5. Incorrect NPI Formatting – Dropping a leading zero or adding a space. The claim fails the syntax check and never reaches the payer That alone is useful..

6. Overlooking Prior Authorization Numbers – If a service required pre‑approval and you forget to include the auth number, the claim is flagged DME‑100 (authorization missing).

7. Using Out‑dated CPT Codes – The CPT manual updates yearly. A code retired in 2023 will bounce back with a “code not found” error.

Practical Tips – What Actually Works

• Run Eligibility in Real Time – Most clearinghouses offer an API that tells you instantly if a member is active, what the copay is, and whether a prior auth is needed.

• Build a “Code‑Pair” Cheat Sheet – Keep a spreadsheet of the top 20 services you bill, with the correct diagnosis, CPT, and any required modifier Easy to understand, harder to ignore. Simple as that..

• Validate Before You Send – Use your clearinghouse’s “test submit” feature. It catches syntax errors before the claim hits the payer’s engine.

• Automate Modifier Logic – Some practice‑management tools let you set rules (e.g., “If two lines on the same date have the same CPT, automatically add ‑59”) Worth knowing..

• Schedule Weekly Claim Audits – Pull a random sample of 50 claims, compare the submitted data to the EMR notes, and flag any discrepancies That's the part that actually makes a difference. But it adds up..

• Stay on Top of Code Updates – Subscribe to the CPT and ICD‑10 newsletters. A quick 5‑minute read each month prevents a cascade of denials Most people skip this — try not to..

• put to work the 835 ERA – Import the remittance advice into your billing software; it will automatically reconcile payments and highlight rejections for follow‑up.

FAQ

Q: Do I need to submit a claim for every single service, even if the patient paid cash?
A: Not always. If the patient pays the full amount and you’ve signed a waiver, you can mark the claim as “self‑pay” and skip submission. But many contracts require you to submit anyway to get the portion the insurer would have covered.

Q: What’s the difference between an 837P and an 837I?
A: 837P is for professional services (physicians, therapists). 837I is for institutional services (hospital stays, inpatient labs). Use the one that matches the provider type.

Q: How soon should I resend a denied claim?
A: After you correct the error, resend within 48 hours. Most payers have a “clean‑up window” where they’ll process the corrected claim without resetting the denial clock.

Q: Can I bundle multiple services on one claim line?
A: Only if the payer’s fee schedule allows it and the services share the same CPT code and modifiers. Otherwise, separate lines avoid bundling rejections.

Q: What does “CO‑45” mean on an ERA?
A: It’s a claim adjustment code for “Charges exceed your fee schedule.” Put another way, the payer applied its contracted rate, which is lower than what you billed.

That’s the whole picture: the data you collect, the exact file you send, the common pitfalls, and a handful of tricks that keep the money moving.

Next time you stare at a blank claim screen, remember it’s not just a form—it’s a conversation with the payer. Get the details right, and the conversation ends with a payment; get them wrong, and you’ll be stuck in a game of “back‑and‑forth” that no one enjoys Practical, not theoretical..

Happy billing!

Putting It All Together

When you think of the billing workflow, picture a relay race: the data capture is the first baton, the claim file is the sprint, and the payer response is the finish line. Each handoff must be clean, or the runner slows, stalls, or even drops the baton. By treating the claim as a precise conversation—complete, coded, and compliant—you give the payer the exact information they need to process quickly and accurately.

Quick‑Start Checklist

Final Thoughts

You might think that a single claim is just a line in a spreadsheet, but it’s really a data‑rich packet that travels thousands of miles—through clearinghouses, firewalls, and payer systems—before it reaches your bank account. The fewer errors you make, the faster that packet moves, and the sooner your practice sees the revenue that belongs to it Simple, but easy to overlook..

Remember:

• Clarity beats speed – a well‑coded, fully documented claim gets paid faster than a rushed, incomplete one.
• Automation is a partner, not a crutch – let software handle repetitive tasks, but keep a human eye on the logic.
• Stay informed – coding rules, payer policies, and technology standards evolve; keep your team updated.

By integrating these practices into your daily workflow, you’ll transform the billing process from a manual, error‑prone chore into a streamlined, revenue‑generating engine The details matter here..

So the next time your team gathers around a blank claim screen, they’ll know this isn’t just paperwork—it’s a precise, data‑driven dialogue with the payer. Nail the details, and the conversation ends with a payment; miss a key point, and you’ll be stuck in a cycle of back‑and‑forth that no one enjoys Less friction, more output..

Happy billing—and may your claims run smoother than a well‑oiled machine!