ICD-10-PCS Inpatient Procedure Codes

In plain language

Every surgery or procedure performed on a hospital inpatient in the United States is described with a seven-character code where each character answers a specific question about the procedure — what type, which body system, what the surgeon did, which body part, how they got there, what was left in, and any additional detail. These ICD-10-PCS codes appear only on the hospital's inpatient facility bill, not on the surgeon's separate bill or on any outpatient record, so researchers who look only at ICD-10-PCS will miss all procedures done in outpatient surgery centers or clinics. The code system has been in use since October 2015 and replaced an older, less detailed system that used shorter numeric codes.

ICD-10-PCS

(International Classification of Diseases, 10th Revision, Procedure Coding System) is the US standard for reporting inpatient hospital procedures. It replaced ICD-9-CM Volume 3 on October 1, 2015. CMS maintains the system and releases annual updates each October 1. The code set is in the public domain. As of recent fiscal years the system contains approximately 78,000+ valid codes; the exact count grows with each annual update as new procedures, devices, and qualifiers are incorporated.

The seven-axis architecture (Medical and Surgical section)

Every ICD-10-PCS code is exactly seven characters long — alphanumeric, using digits 0-9 and letters A-Z with I and O excluded to prevent confusion with 1 and 0. Each character position encodes one and only one clinical axis:

• Position 1 — Section: The broad type of procedure. Section 0 is Medical and Surgical (the

• Position 2 — Body System: Within Medical and Surgical, the anatomical system involved. Values

• Position 3 — Root Operation: The objective of the procedure — this is the most analytically
• Resection (T): Cutting out or off, without replacement, ALL of a body part. A total knee
• Excision (B): Cutting out or off, without replacement, a PORTION of a body part. Used for
• Replacement (R): Putting in or on a biological or synthetic substitute that physically takes
• Repair (Q): Restoring, to the extent possible, a body part to its normal anatomic structure
• Bypass (1): Altering the route of passage to include an upstream body part (e.g., coronary
• Fusion (G): Joining together portions of an articular body part, rendering the articular body
• Other key root operations: Dilation (7), Drainage (9), Extirpation (C — removing solid

• Position 4 — Body Part: The specific anatomical site operated upon, defined within the body

• Position 5 — Approach: The technique used to reach the operative site. Open (0), Percutaneous

• Position 6 — Device: Any material or object left in or on the body at the end of the procedure.

• Position 7 — Qualifier: An additional attribute that further specifies the procedure. Common

How codes are constructed, not selected

Unlike ICD-10-CM (where codes are looked up in a tabular list) or CPT (where codes are selected from a flat numbered list with hierarchical groupings), ICD-10-PCS codes are built from a set of tables. Each table specifies one combination of section + body system + root operation, and the analyst reads across to pick one value per remaining position. This means the system is genuinely combinatorial: for a given root operation on a given body system, all clinically meaningful combinations of body part, approach, device, and qualifier generate valid codes. There is no principal list of 78,000 codes to memorize; coders and researchers navigate tables. RWE analysts who attempt to define a procedure cohort by building a "list of codes" without reading the applicable table definitions — especially the root operation definitions — risk systematic misclassification. The root operation is the place where ICD-10-PCS most often surprises clinicians and analysts who assume the code describes what was done rather than what was precisely intended.

Coding coverage and scope: inpatient facility only

This is the single most important scoping constraint for RWE. ICD-10-PCS codes appear only on UB-04/837I claims (hospital inpatient facility bills), specifically in the procedure code fields (FL74: principal procedure, FL75-FL80: additional procedures). They are NEVER used on:

• Physician/professional claims (CMS-1500/837P) — those use CPT and HCPCS
• Hospital outpatient facility claims (also UB-04, but the procedure fields use CPT/HCPCS)
• Ambulatory surgery center (ASC) claims — CPT/HCPCS
• Part B administered drug/biologic claims — HCPCS J-codes

The result is a sharp population-of-care segmentation. Total knee arthroplasty performed as an inpatient admission generates an ICD-10-PCS code on the facility claim. The same procedure performed at an outpatient surgery center generates CPT 27447 on the ASC facility claim and on the surgeon's professional claim — no ICD-10-PCS. As the shift toward outpatient surgical care has accelerated, an algorithm using ICD-10-PCS alone increasingly misses real cases in the sicker-appearing inpatient-only subgroup. Any procedure definition relying exclusively on ICD-10-PCS will miss all outpatient facility cases and all professional claims, systematically under-counting and biasing the identified cohort toward longer, costlier inpatient stays.

Complete procedure ascertainment in US claims almost always requires a union of ICD-10-PCS (inpatient facility) + CPT/HCPCS (physician and outpatient facility) + revenue center codes (outpatient facility type-of-service confirmation). The relative contribution of ICD-10-PCS versus CPT changes over time as procedure migration from inpatient to outpatient settings continues; analysts should report the fraction captured by each stream as a sensitivity diagnostic.

ICD-10-PCS vs. ICD-9-CM Volume 3

The predecessor, ICD-9-CM Volume 3, used a four-character numeric code with two-character category hierarchies. Its coverage was incomplete, its specificity was lower, and its hierarchical structure was not systematically multi-axial — procedure categorization was often inconsistent across anatomic areas. ICD-10-PCS brought standardized multi-axial logic, explicit approach and device coding, and a larger code space. The transition on 2015-10-01 created a coding discontinuity: time-series analyses crossing October 2015 must account for the change, and ICD-9-to-ICD-10-PCS crosswalks (GEMs — General Equivalence Mappings — provided by CMS) are imperfect because many ICD-9-CM Vol 3 codes map to multiple ICD-10-PCS codes and vice versa. For any cohort or outcome algorithm that spans the transition date, the crosswalk mapping uncertainty must be quantified and reported.

Relationship to MS-DRGs

Medicare Severity Diagnosis Related Groups (MS-DRGs) are assigned by the Medicare grouper software based on the combination of the principal diagnosis (ICD-10-CM), secondary diagnoses, and procedures (ICD-10-PCS). The presence or absence of a "surgical" ICD-10-PCS code — and specifically which major diagnostic category and surgical hierarchy it triggers — determines whether a discharge is classified into a surgical MS-DRG versus a medical MS-DRG. Surgical DRGs command higher payments. RWE analysts working with DRG-based cost data or severity-adjustment that uses DRG must understand that the ICD-10-PCS code drives this classification: an error in the PCS code changes the DRG assignment and distorts cost comparisons.

Relationship to OMOP CDM

In the Observational Medical Outcomes Partnership (OMOP) common data model, ICD-10-PCS source codes are mapped to the Procedure domain using standard concepts from the SNOMED-CT procedure hierarchy or the OMOP standard concept set for procedures. The source code (ICD-10-PCS character string) is preserved in the source_concept_id column of the procedure_occurrence table; the standard_concept_id is the mapped SNOMED or OMOP concept. Analysts building procedure cohorts in OMOP should query the procedure_occurrence table using standard_concept_id (SNOMED) unless they have specific reason to query by source code. OMOP's concept mapping for ICD-10-PCS is generally good for common surgical procedures but may lag for new technology (Section X) codes that have been recently added to the ICD-10-PCS tables.

Pros, cons, and trade-offs

— specific and comparative.

• vs CPT procedure codes (professional and outpatient facility claims): CPT is axis-free — each

• vs ICD-9-CM Volume 3 (the predecessor for pre-October-2015 data): ICD-9-CM Vol 3 is less

• vs HCPCS Level II (J-codes and device/supply codes): HCPCS Level II covers drugs administered

• vs revenue center codes (UB-04 revenue codes): Revenue codes describe the type of service and

When to use

- When building a procedure-based cohort from hospital inpatient claims or inpatient facility UB-04 data: any surgical or invasive procedure performed during a hospital stay (cardiac surgery, joint replacement, major abdominal or thoracic surgery, organ transplant, spine surgery, etc.). - When the research question is specific to inpatient care — length of stay, inpatient costs, hospital charges, discharge disposition, perioperative complications — where the inpatient setting is itself part of the phenotype. - When you need the approach, device, and qualifier axes for the specific clinical question (e.g., open versus laparoscopic, cemented versus uncemented joint implant, autologous versus synthetic graft). - When studying MS-DRG assignment, hospital payment, or hospital-based resource utilization where ICD-10-PCS codes directly drive the DRG grouper. - As part of a union code set (with CPT/HCPCS) for comprehensive multi-setting procedure ascertainment in comparative effectiveness or safety studies. - When using OMOP CDM: query procedure_occurrence by standard SNOMED concept mapped from ICD-10-PCS source codes, and validate source capture rates.

When NOT to use — and when it is actively misleading or dangerous

• **As the sole procedure identifier when the study population includes outpatient or ambulatory

• When relying on the code description rather than the root operation definition. The written

• For pre-October 2015 inpatient data. ICD-10-PCS did not exist in US data before FY2016. Any

• **When crossing the October 2015 ICD-9-CM-to-ICD-10-PCS transition date without documenting the

• **When the procedure of interest is predominantly outpatient and was never routinely performed

• When building a positional pattern for prefix matching without also testing specificity.

Data-source operational depth

• Medicare FFS (Parts A/B/D) inpatient claims: ICD-10-PCS codes appear on the inpatient SAF

• Commercial claims (employer-sponsored and ACA marketplace): ICD-10-PCS codes appear in the

• All-payer inpatient discharge databases (HCUP NIS, SID, KID): The Healthcare Cost and

• EHR: ICD-10-PCS is a billing code, not a clinical code — it does not natively appear in

• OMOP CDM: ICD-10-PCS source codes are mapped to procedure_occurrence via the standard concept

Worked example

Scenario

A health outcomes researcher wants to identify all patients in a Medicare FFS inpatient claims database who received a total knee replacement (TKR) during 2022. She knows from reading the ICD-10-PCS tables that a TKR maps to root operation Replacement (R), body system Lower Joints (R), and she wants to understand how to decompose the code, build the search pattern, and then confirm she is capturing the right set of body parts. She uses the publicly documented example code 0SRC0JZ (Replacement of Right Knee Joint with Synthetic Substitute, Open Approach) to walk through the logic, then writes the positional regex that finds all knee joint replacements regardless of laterality, device, or qualifier.

Dataset

Seven-axis decomposition of ICD-10-PCS code 0SRC0JZ — total knee replacement example

Steps

• Position 1 = 0 (zero): Medical and Surgical section. All common inpatient surgeries live here.

• Position 2 = S: Lower Joints body system. Both hips, knees, ankles, and foot joints are in body system R (Lower Joints); note the section character is 0, so the full prefix is 0S.

• Position 3 = R: Root Operation Replacement. ICD-10-PCS defines Replacement as 'putting in or on biological or synthetic material that physically takes the place of all or a portion of a body part.' A total knee arthroplasty — where the natural knee surfaces are removed and a prosthesis is seated — fits this definition. Root operation Repair (Q) would be wrong because nothing is replaced; root operation Supplement (U) would be wrong because the natural joint surface is not retained.

• Position 4 = C: Right Knee Joint. Left Knee Joint = D, Right Knee Joint = C. A study of bilateral TKRs needs both C and D in position 4.

• Position 5 = 0: Open approach. A minimally invasive or robotic-assisted approach with an open cavity would still typically be coded Open if the joint cavity is opened. Percutaneous Endoscopic (4) applies to fully arthroscopic work.

• Position 6 = J: Synthetic Substitute. Other device values include 6 (Autologous Tissue Substitute) and L (Nonautologous Tissue Substitute). Cemented vs uncemented implants are NOT distinguished in position 6 in base ICD-10-PCS — both are J.

• Position 7 = Z: No Qualifier. For many joint replacements the qualifier is Z.

• To find ALL knee replacements (right and left, any device, any qualifier), build a regex that fixes positions 1-3 (0SR) and position 4 as C or D, allowing any value in positions 5-7. The regex ^0SR[CD][0-9A-HJ-NP-Z]{3}$ matches all valid knee replacement codes in that combinatorial space and excludes non-knee body parts by pinning position 4.

• expr = total valid 7-character codes in the result set where positions 1-3 are 0SR and position 4 is C or D. The number of valid combinations is determined by the table: typically 2 body parts x available approaches x available devices x available qualifiers. For illustration, if there are 1 approach, 5 device values, and 1 qualifier value, the count = 2 1 5 * 1 = 10 codes — each representing a clinically distinct combination.

Result

The 7-character string 0SRC0JZ decodes as: Open total knee replacement of the Right Knee Joint using a Synthetic Substitute. The positional regex ^0SR[CD][0-9A-HJ-NP-Z]{3}$ captures all knee joint replacements regardless of laterality (C=right, D=left), device type, and qualifier. A researcher using this pattern instead of a manually curated flat list guarantees that newly added table combinations in annual ICD-10-PCS updates are automatically included — a key advantage of the multi-axial architecture over flat code lists.

Timeline Spec

Title

ICD-10-PCS code axis decomposition for 0SRC0JZ (total knee replacement)

Window

Start

2015-10-01

End

2015-10-07

Label

ICD-10-PCS effective date: Oct 1, 2015

Events

• Label

  Position 1: Section (0=Med/Surg)

  Start

  2015-10-01

  Length Days

  1

  Quantity

  char 1

• Label

  Position 2: Body System (S=Lower Joints)

  Start

  2015-10-02

  Length Days

  1

  Quantity

  char 2

• Label

  Position 3: Root Op (R=Replacement)

  Start

  2015-10-03

  Length Days

  1

  Quantity

  char 3

• Label

  Position 4: Body Part (C=Rt Knee)

  Start

  2015-10-04

  Length Days

  1

  Quantity

  char 4

• Label

  Position 5: Approach (0=Open)

  Start

  2015-10-05

  Length Days

  1

  Quantity

  char 5

• Label

  Position 6: Device (J=Synthetic)

  Start

  2015-10-06

  Length Days

  1

  Quantity

  char 6

• Label

  Position 7: Qualifier (Z=None)

  Start

  2015-10-07

  Length Days

  1

  Quantity

  char 7

Spans

• Kind

  covered

  Start

  2015-10-01

  End

  2015-10-07

  Label

  7-axis code 0SRC0JZ

Result

Label

0SRC0JZ = Open Replacement, Right Knee Joint, Synthetic Substitute — 7 axes, 7 characters

Value

7

Runnable example

import re

# ICD-10-PCS character alphabet: digits 0-9 and uppercase letters except I and O.
_VALID_CHAR = re.compile(r'^[0-9A-HJ-NP-Z]{7}$')

# Medical & Surgical section position labels (section 0 only).
_MS_AXES = ["Section", "Body System", "Root Operation",
            "Body Part", "Approach", "Device", "Qualifier"]

# Selected root operation values for the Medical & Surgical section (section 0).
ROOT_OPS = {
    "0": "Alteration",       "1": "Bypass",         "2": "Change",
    "3": "Control",          "4": "Creation",        "5": "Destruction",
    "6": "Detachment",       "7": "Dilation",        "8": "Division",
    "9": "Drainage",         "B": "Excision",        "C": "Extirpation",
    "D": "Extraction",       "F": "Fragmentation",   "G": "Fusion",
    "H": "Insertion",        "J": "Inspection",      "K": "Map",
    "L": "Occlusion",        "M": "Reattachment",    "N": "Release",
    "P": "Removal",          "Q": "Repair",          "R": "Replacement",
    "S": "Reposition",       "T": "Resection",       "U": "Supplement",
    "V": "Restriction",      "W": "Revision",        "X": "Transfer",
    "Y": "Transplantation",
}


def validate_pcs_code(code: str) -> bool:
    """Return True if code is a syntactically valid ICD-10-PCS string.

    Rules: exactly 7 characters; only digits 0-9 and uppercase A-Z
    excluding I and O (which are omitted to avoid confusion with 1 and 0).
    This is a format check only — it does not confirm the code appears in
    the official CMS PCS tables for any specific fiscal year.
    """
    return bool(_VALID_CHAR.match(str(code).upper()))


def decompose_pcs_code(code: str) -> dict:
    """Decompose a Medical & Surgical section (section 0) ICD-10-PCS code.

    Returns a dict mapping each axis name to its character value.
    Raises ValueError for codes that are not 7 valid characters or not
    in section 0 (Medical & Surgical).
    """
    code = str(code).upper()
    if not validate_pcs_code(code):
        raise ValueError(
            f"Invalid ICD-10-PCS code: {code!r}. "
            "Must be 7 characters using 0-9 and A-Z except I and O."
        )
    if code[0] != "0":
        raise ValueError(
            f"Code {code!r} is not Medical & Surgical (section 0). "
            "Position 1 must be '0' for this decomposition."
        )
    result = {axis: char for axis, char in zip(_MS_AXES, code)}
    # Add root operation label when recognised.
    root_char = code[2]
    if root_char in ROOT_OPS:
        result["Root Operation Label"] = ROOT_OPS[root_char]
    return result


def build_pcs_code_set(
    section: str,
    body_system: str,
    root_operation: str,
    body_parts: list[str] | None = None,
) -> re.Pattern:
    """Return a compiled regex that matches all ICD-10-PCS codes for the given
    combination of section, body system, and root operation, optionally filtered
    to a list of body part character values (position 4).

    The pattern fixes positions 1-3 and, if body_parts is supplied, anchors
    position 4 to those values; positions 5-7 are unconstrained (any valid
    ICD-10-PCS character). Use this to build a table-aware code set that
    automatically covers new fiscal-year additions without manual enumeration.

    Example — all Open knee joint replacements (right and left):
        build_pcs_code_set("0", "S", "R", body_parts=["C", "D"])
        matches: 0SR[CD][0-9A-HJ-NP-Z]{3}
    """
    for label, val in (("section", section), ("body_system", body_system),
                       ("root_operation", root_operation)):
        val = str(val).upper()
        if not _VALID_CHAR.match(val + "000000"):  # pad to 7 for regex test
            raise ValueError(f"Invalid PCS character for {label}: {val!r}")
    prefix = (str(section).upper()
              + str(body_system).upper()
              + str(root_operation).upper())
    if body_parts:
        valid_bp = [c.upper() for c in body_parts if _VALID_CHAR.match(c + "000000")]
        if not valid_bp:
            raise ValueError("No valid body part characters provided.")
        bp_class = "[" + "".join(valid_bp) + "]"
    else:
        bp_class = "[0-9A-HJ-NP-Z]"
    # Positions 5-7: any valid ICD-10-PCS character (excludes I and O).
    tail = "[0-9A-HJ-NP-Z]{3}"
    return re.compile(f"^{prefix}{bp_class}{tail}$")


# ── Worked example ──────────────────────────────────────────────────────────
if __name__ == "__main__":
    # Validate and decompose 0SRC0JZ (total knee replacement, right, open, synthetic).
    code = "0SRC0JZ"
    print(f"Valid: {validate_pcs_code(code)}")   # -> True
    axes = decompose_pcs_code(code)
    for axis, val in axes.items():
        print(f"  {axis}: {val}")

    # Build a regex for all knee joint replacements (right=C, left=D).
    tkr_pattern = build_pcs_code_set("0", "S", "R", body_parts=["C", "D"])
    test_codes = ["0SRC0JZ", "0SRD0JZ", "0SRC049", "0LRB0JZ"]  # last = not knee
    for c in test_codes:
        print(f"  {c}: {'MATCH' if tkr_pattern.match(c) else 'no match'}")
    # Expected: 0SRC0JZ=MATCH, 0SRD0JZ=MATCH, 0SRC049=no match (invalid char 4/position 5?),
    # 0LRB0JZ=no match (section 0 body system L = Tendons, not Lower Joints).

# ICD-10-PCS character alphabet: 0-9 and A-Z except I and O.
.PCS_VALID <- "^[0-9A-HJ-NP-Z]{7}$"

.MS_AXES <- c("Section", "Body_System", "Root_Operation",
              "Body_Part", "Approach", "Device", "Qualifier")

.ROOT_OPS <- c(
  "0"="Alteration",    "1"="Bypass",        "2"="Change",
  "3"="Control",       "4"="Creation",       "5"="Destruction",
  "6"="Detachment",    "7"="Dilation",       "8"="Division",
  "9"="Drainage",      "B"="Excision",       "C"="Extirpation",
  "D"="Extraction",    "F"="Fragmentation",  "G"="Fusion",
  "H"="Insertion",     "J"="Inspection",     "K"="Map",
  "L"="Occlusion",     "M"="Reattachment",   "N"="Release",
  "P"="Removal",       "Q"="Repair",         "R"="Replacement",
  "S"="Reposition",    "T"="Resection",       "U"="Supplement",
  "V"="Restriction",   "W"="Revision",        "X"="Transfer",
  "Y"="Transplantation"
)

#' Validate ICD-10-PCS code format.
#' @param code Character scalar or vector.
#' @return Logical. TRUE = syntactically valid; does not confirm FY table membership.
validate_pcs_code <- function(code) {
  grepl(.PCS_VALID, toupper(as.character(code)))
}

#' Decompose a Medical & Surgical section (section 0) ICD-10-PCS code into its seven axes.
#' @param code Single 7-character ICD-10-PCS code.
#' @return Named character vector with one element per axis plus Root_Operation_Label.
decompose_pcs_code <- function(code) {
  code <- toupper(as.character(code))
  if (!validate_pcs_code(code))
    stop("Invalid ICD-10-PCS code: ", code,
         ". Must be 7 characters from [0-9A-HJ-NP-Z].")
  if (substr(code, 1, 1) != "0")
    stop("Code ", code, " is not Medical & Surgical (section 0).")
  chars <- strsplit(code, "")[[1]]
  result <- setNames(chars, .MS_AXES)
  root_char <- chars[3]
  if (root_char %in% names(.ROOT_OPS))
    result["Root_Operation_Label"] <- .ROOT_OPS[[root_char]]
  result
}

#' Build a positional regex matching all ICD-10-PCS codes for a given
#' section + body_system + root_operation, optionally filtered to specific body parts.
#'
#' @param section    1-character section value (e.g., "0" for Medical & Surgical).
#' @param body_system 1-character body system value (e.g., "S" for Lower Joints).
#' @param root_op    1-character root operation value (e.g., "R" for Replacement).
#' @param body_parts Optional character vector of position-4 values to match.
#' @return A compiled regex pattern string (pass to grepl / regexpr).
build_pcs_regex <- function(section, body_system, root_op, body_parts = NULL) {
  any_valid <- "[0-9A-HJ-NP-Z]"
  prefix <- paste0(toupper(section), toupper(body_system), toupper(root_op))
  if (!is.null(body_parts) && length(body_parts) > 0) {
    bp_chars <- paste0(toupper(body_parts), collapse = "")
    bp_class  <- paste0("[", bp_chars, "]")
  } else {
    bp_class <- any_valid
  }
  paste0("^", prefix, bp_class, any_valid, "{3}$")
}

## Worked example ----------------------------------------------------------
code <- "0SRC0JZ"
cat("Valid:", validate_pcs_code(code), "\n")
print(decompose_pcs_code(code))

# Regex for all knee joint replacements (Right Knee = C, Left Knee = D)
tkr_regex <- build_pcs_regex("0", "S", "R", body_parts = c("C", "D"))
cat("TKR regex:", tkr_regex, "\n")
test_codes <- c("0SRC0JZ", "0SRD0JZ", "0SRC049", "0LRB0JZ")
cat("Match results:\n")
print(data.frame(code = test_codes, match = grepl(tkr_regex, test_codes)))