Healthcare Claims and Revenue Cycle Analytics Set (US)

HLTRCM999· 1.9M records · 50 tables · v1.0.0 · Updated 2026-09-01

Healthcare Healthcare Claims and Revenue Cycle Dataset API

CSV JSON SQLhealthcarerevenue-cyclemedical-claimsdenial-managementclaims-analyticspayer-contractsunderpayment-recoveryaccounts-receivablemedical-billingus-healthcare

Overview

HLTRCM999 follows a synthetic United States provider organisation from registration to cash: eligibility, prior authorisation, encounter, coding, charge capture, claim assembly, scrubbing, submission, clearinghouse acknowledgement, adjudication, remittance, denial, rework, appeal, patient statement, collection agency placement and write off. Fifty linked tables, and every stage joins to the one before it. This is a billing warehouse, not a clinical one. Diagnoses and services are present because they drive the money, not because the set is trying to be a medical record. That distinction is deliberate: a synthetic clinical record invites people to draw conclusions about medicine from generated data, and a billing warehouse does not. CPT is absent by necessity rather than oversight. The code set and its descriptors are American Medical Association copyright and licensed, so a commercial dataset cannot carry them. Every procedure here is HCPCS Level II or a UB-04 revenue code, both published freely by CMS and the National Uniform Billing Committee, and the revenue codes matter more than they look: they carry the facility side of an institutional claim, which is where most of a hospital bill actually sits. The contract is what makes the set analysable. Negotiated rates by service category mean every line carries the allowed amount the contract required beside the one the payer actually paid, so underpayment against contract is computable rather than asserted, and most of it was never worked, which is exactly the situation in the field. Cost sharing is modelled per payer class rather than as one shape: Medicaid and workers compensation carry none, Medicare Part B is a small deductible then a flat twenty percent, and only commercial looks like the textbook diagram. Deductibles and out of pocket maximums carry an external component, because patients spend most of both at providers this organisation never sees. Three things move across the window. A large commercial payer tightens prior authorisation in March 2024 and authorisation denials against it climb. A claim scrubber goes in in January 2025 and the missing information denial that dominates every real denial mix falls away. And every January the deductibles reset, which is the most reliable seasonal pattern in United States healthcare receivables. Identifiers come from keyed hashes, so no column runs 0001, 0002, 0003.

Analytics

Four entries from the packaged tables, with the performance the dataset records for them. Every value below is read from the shipped files.

ClaimsCLAIMSregistration through to adjudication

58,343Claims

88.2%Clean claim rate

Claims notified, countClaims notified, count

1 / 4

Row Counts by Table

Counted from the files that ship, not estimated.

Table	Rows
rcm_claims	58,343
rcm_claim_lines	182,374
rcm_charges	192,622
rcm_encounters	61,915
rcm_encounter_diagnoses	123,321
rcm_encounter_procedures	121,619
rcm_patients	21,000
rcm_coverage	24,997
rcm_patient_addresses	23,918
rcm_patient_contacts	40,521
rcm_eligibility_checks	54,853
rcm_authorisations	15,726
rcm_claim_submissions	61,186
rcm_claim_status_history	261,340
rcm_remittances	56,216
rcm_remittance_lines	175,712
rcm_adjustments	178,032
rcm_payments	85,575
rcm_denials	4,775
rcm_appeals	1,074
rcm_underpayments	3,183
rcm_patient_statements	43,226
rcm_collections	6,133
rcm_write_offs	12,455
rcm_ar_snapshots	6,639
rcm_monthly_revenue_cycle	42
rcm_monthly_payer_performance	1,091
rcm_monthly_department_metrics	10,539
rcm_monthly_denial_summary	416
rcm_payers	26
rcm_payer_plans	185
rcm_contracts	1,150
rcm_contract_rates	19,587
rcm_facilities	71
rcm_departments	318
rcm_providers	1,139
rcm_payer_types	10
rcm_denial_reasons	15
rcm_claim_statuses	11
rcm_adjustment_types	7
rcm_ar_buckets	6
rcm_icd_codes	48
rcm_icd_chapters	18
rcm_hcpcs_codes	36
rcm_revenue_codes	24
rcm_place_of_service	14
rcm_specialties	22
rcm_facility_types	10
rcm_cities	86
rcm_states	39

Table Relationships

One parent record and seven child tables, each joined back on the same key.

70%

Loading diagram

Schema

Every table ships with typed columns, referential integrity, and documentation.

rcm_claims· Rows: 58,343

Column	Type	Description
claim_id	`varchar(24)`	Surrogate key for the claim.
encounter_id	`varchar(24)`	Encounter the claim was raised from.
patient_id	`varchar(16)`	Patient the claim relates to.
facility_id	`varchar(16)`	Facility that billed the claim.
coverage_id	`varchar(16)`	Coverage the claim was filed against.
payer_id	`varchar(16)`	Payer the claim was filed to.
payer_type_code	`varchar(24)`	Payer category of the coverage billed.

+21 more columns in rcm_claims. The full schema ships with the download.

rcm_claim_lines· Rows: 182,374

Column	Type	Description
claim_line_id	`varchar(24)`	Surrogate key for the claim line.
claim_id	`varchar(24)`	Claim the line belongs to.
charge_id	`varchar(24)`	Charge the line was billed from.
line_number	`varchar(8)`	Position of the line on the claim.
hcpcs_code	`varchar(8)`	HCPCS Level II code on a professional line.
revenue_code	`varchar(8)`	UB-04 revenue code on an institutional line.
line_modifier	`varchar(16)`	HCPCS modifier carried on the line.

+12 more columns in rcm_claim_lines. The full schema ships with the download.

rcm_charges· Rows: 192,622

Column	Type	Description
charge_id	`varchar(24)`	Surrogate key for the charge line.
encounter_procedure_id	`varchar(24)`	Coded service the charge was raised from. Empty on an institutional revenue code line, which is billed from the facility record rather than from a coded procedure.
encounter_id	`varchar(24)`	Encounter the charge belongs to.
patient_id	`varchar(16)`	Patient the charge was raised against.
facility_id	`varchar(16)`	Facility that raised the charge.
department_id	`varchar(16)`	Department that raised the charge.
rendering_provider_id	`varchar(16)`	Provider who delivered the service.

+20 more columns in rcm_charges. The full schema ships with the download.

rcm_encounters· Rows: 61,915

Column	Type	Description
encounter_id	`varchar(24)`	Surrogate key for the encounter.
patient_account_number	`varchar(16)`	Patient account number for this episode, which is the number that appears on a statement.
patient_id	`varchar(16)`	Patient seen.
facility_id	`varchar(16)`	Facility the encounter took place at.
department_id	`varchar(16)`	Department that delivered the care.
rendering_provider_id	`varchar(16)`	Provider who delivered the care.
coverage_id	`varchar(16)`	Coverage that was in force on the date of service. A visit under lapsed coverage points at the lapsed record, because that is what the claim was filed against.

+8 more columns in rcm_encounters. The full schema ships with the download.

rcm_encounter_diagnoses· Rows: 123,321

Column	Type	Description
encounter_diagnosis_id	`varchar(24)`	Surrogate key for the coded diagnosis.
encounter_id	`varchar(24)`	Encounter the diagnosis was coded on.
icd10_code	`varchar(16)`	ICD-10-CM diagnosis code.
diagnosis_role	`varchar(16)`	Whether the diagnosis is the principal one or a secondary.
diagnosis_sequence	`integer`	Position of the diagnosis in the coded sequence, with the principal first.
is_principal	`varchar(16)`	Y when this is the principal diagnosis for the encounter.
present_on_admission	`varchar(16)`	Present on admission indicator, which affects payment on an inpatient claim.

+1 more columns in rcm_encounter_diagnoses. The full schema ships with the download.

rcm_encounter_procedures· Rows: 121,619

Column	Type	Description
encounter_procedure_id	`varchar(24)`	Surrogate key for the coded service.
encounter_id	`varchar(24)`	Encounter the service was delivered on.
hcpcs_code	`varchar(8)`	HCPCS Level II code for the service.
procedure_modifier	`varchar(16)`	HCPCS modifier where one applies, for example 25 for a distinct evaluation or LT and RT for laterality.
service_units	`integer`	Units of the service delivered.
procedure_sequence	`integer`	Position of the service within the encounter.
performed_on	`date`	Date the service was performed, which can fall within an inpatient stay rather than on the admission date.

+2 more columns in rcm_encounter_procedures. The full schema ships with the download.

rcm_patients· Rows: 21,000

Column	Type	Description
patient_id	`varchar(16)`	Surrogate key for the patient.
medical_record_number	`varchar(16)`	Medical record number as the provider would hold it. Derived from a keyed hash rather than issued in sequence.
first_name	`varchar(16)`	Patient first name. The person is generated.
middle_initial	`varchar(16)`	Patient middle initial where one is recorded.
last_name	`varchar(16)`	Patient last name.
sex	`varchar(16)`	Sex as recorded for billing purposes.
date_of_birth	`date`	Date of birth.

+9 more columns in rcm_patients. The full schema ships with the download.

rcm_coverage· Rows: 24,997

Column	Type	Description
coverage_id	`varchar(16)`	Surrogate key for the coverage record.
patient_id	`varchar(16)`	Patient the coverage belongs to.
plan_id	`varchar(16)`	Benefit plan providing the coverage. Empty for self pay.
payer_type_code	`varchar(24)`	Payer category of the coverage.
member_id	`varchar(16)`	Member identifier as it appears on the card. Alphanumeric with a plan prefix, never a running number.
group_number	`varchar(8)`	Employer or plan group number.
coverage_rank	`varchar(16)`	Whether this coverage is primary or secondary for the patient.

+5 more columns in rcm_coverage. The full schema ships with the download.

rcm_patient_addresses· Rows: 23,918

Column	Type	Description
address_id	`varchar(16)`	Surrogate key for the address record.
patient_id	`varchar(16)`	Patient the address belongs to.
address_type	`varchar(16)`	Whether the address is the primary, a previous or a separate mailing address.
street_address	`varchar(32)`	Street number and name.
unit_designator	`varchar(16)`	Secondary unit designator such as an apartment or suite, using the USPS abbreviations.
city_id	`varchar(16)`	City of the address.
state_code	`varchar(8)`	State of the address.

+4 more columns in rcm_patient_addresses. The full schema ships with the download.

rcm_patient_contacts· Rows: 40,521

Column	Type	Description
contact_id	`varchar(16)`	Surrogate key for the contact record.
patient_id	`varchar(16)`	Patient the contact belongs to.
contact_type	`varchar(16)`	Whether the contact is a mobile number, home number or email address.
contact_value	`varchar(56)`	The contact value. Telephone numbers use the 555 exchange reserved for fictitious use, and email domains were resolved at build time and discarded if they answered.
is_preferred	`varchar(16)`	Y when this is the preferred contact method.
sms_consent	`varchar(16)`	Y when the patient has consented to text message contact. Empty for contact types where it does not apply.
verified_on	`date`	Date the contact detail was last verified.

+1 more columns in rcm_patient_contacts. The full schema ships with the download.

rcm_eligibility_checks· Rows: 54,853

Column	Type	Description
eligibility_check_id	`varchar(24)`	Surrogate key for the eligibility verification.
encounter_id	`varchar(24)`	Encounter the check was run for.
coverage_id	`varchar(16)`	Coverage that was checked.
checked_on	`date`	Date the eligibility request was sent.
eligibility_result	`varchar(24)`	What came back: active, inactive, not found, or the payer was unavailable. A visit that went ahead on an inactive result is very likely to be denied.
reported_deductible_usd	`integer`	Annual deductible the payer reported on the response.
reported_deductible_met_usd	`integer`	Deductible the payer reported as already met, most of which was spent at other providers this organisation never sees.

+3 more columns in rcm_eligibility_checks. The full schema ships with the download.

rcm_authorisations· Rows: 15,726

Column	Type	Description
authorisation_id	`varchar(24)`	Surrogate key for the authorisation request.
encounter_id	`varchar(24)`	Encounter the authorisation was sought for.
coverage_id	`varchar(16)`	Coverage the authorisation was sought under.
authorisation_number	`varchar(16)`	Authorisation number issued by the payer. Empty where authorisation was refused or never obtained.
requested_on	`date`	Date the authorisation was requested.
decided_on	`date`	Date the payer decided.
authorisation_status	`varchar(24)`	Whether the authorisation was approved, denied, still pending or never requested.

+4 more columns in rcm_authorisations. The full schema ships with the download.

rcm_claim_submissions· Rows: 61,186

Column	Type	Description
submission_id	`varchar(24)`	Surrogate key for the submission attempt.
claim_id	`varchar(24)`	Claim submitted.
submission_attempt	`integer`	Attempt number. Attempt two is a corrected claim sent after a denial, which is how most denials are actually resolved.
submitted_on	`date`	Date this attempt was sent.
submission_method	`varchar(24)`	How the claim was sent, for example an EDI 837, a corrected 837, a payer portal or paper.
clearinghouse_batch_id	`varchar(8)`	Batch the claim was transmitted in.
acknowledgement_status	`varchar(16)`	Whether the clearinghouse or payer accepted or rejected the transmission. A rejection is a front end failure and is not an adjudication.

+3 more columns in rcm_claim_submissions. The full schema ships with the download.

rcm_claim_status_history· Rows: 261,340

Column	Type	Description
status_history_id	`varchar(24)`	Surrogate key for the status transition.
claim_id	`varchar(24)`	Claim the transition belongs to.
sequence_number	`varchar(8)`	Position of the transition in the claim history.
claim_status_code	`varchar(24)`	Status the claim moved to.
changed_at	`varchar(32)`	Timestamp of the transition.
previous_status_code	`varchar(16)`	Status the claim moved from. Empty on the first transition.
status_source	`varchar(24)`	What reported the transition, for example the clearinghouse, an 835 remittance or a member of billing staff.

+1 more columns in rcm_claim_status_history. The full schema ships with the download.

rcm_remittances· Rows: 56,216

Column	Type	Description
remittance_id	`varchar(24)`	Surrogate key for the remittance advice.
claim_id	`varchar(24)`	Claim the remittance relates to.
payer_id	`varchar(16)`	Payer that issued the remittance.
check_date	`date`	Date on the payment.
payment_method	`varchar(16)`	How the payer paid, for example electronic funds transfer, cheque or virtual card.
trace_number	`varchar(24)`	Trace number tying the remittance to the payment.
total_paid_usd	`numeric(9,2)`	Total paid across the remittance.

+6 more columns in rcm_remittances. The full schema ships with the download.

rcm_remittance_lines· Rows: 175,712

Column	Type	Description
remittance_line_id	`varchar(24)`	Surrogate key for the remittance line.
remittance_id	`varchar(24)`	Remittance the line belongs to.
claim_id	`varchar(24)`	Claim the line relates to.
charge_id	`varchar(24)`	Charge the line settles.
line_number	`varchar(8)`	Position of the line on the remittance.
hcpcs_code	`varchar(8)`	HCPCS Level II code on a professional line.
revenue_code	`varchar(8)`	UB-04 revenue code on an institutional line.

+12 more columns in rcm_remittance_lines. The full schema ships with the download.

rcm_adjustments· Rows: 178,032

Column	Type	Description
adjustment_id	`varchar(24)`	Surrogate key for the adjustment.
claim_id	`varchar(24)`	Claim the adjustment was posted against.
charge_id	`varchar(24)`	Charge the adjustment was posted against. Empty where the adjustment was booked at claim level.
adjustment_type_code	`varchar(24)`	Type of adjustment, for example a contractual adjustment or a denial write off.
adjustment_amount_usd	`numeric(10,2)`	Amount adjusted.
adjustment_reason_code	`varchar(8)`	Reason code carried with the adjustment.
posted_on	`date`	Date the adjustment was posted.

+2 more columns in rcm_adjustments. The full schema ships with the download.

rcm_payments· Rows: 85,575

Column	Type	Description
payment_id	`varchar(24)`	Surrogate key for the payment.
claim_id	`varchar(24)`	Claim the payment settles. Empty on a patient payment against a statement.
patient_id	`varchar(16)`	Patient the payment relates to.
payer_id	`varchar(16)`	Payer that made the payment. Empty on a patient payment.
payment_source	`varchar(24)`	Where the money came from: the payer, a payer rework, a payer appeal, the patient, or a collection agency.
payment_amount_usd	`numeric(9,2)`	Amount paid.
payment_date	`date`	Date of the payment.

+6 more columns in rcm_payments. The full schema ships with the download.

rcm_denials· Rows: 4,775

Column	Type	Description
denial_id	`varchar(24)`	Surrogate key for the denial.
claim_id	`varchar(24)`	Claim that was denied.
remittance_id	`varchar(24)`	Remittance that carried the denial.
payer_id	`varchar(16)`	Payer that denied.
denial_code	`varchar(8)`	Claim adjustment reason code the payer gave.
adjustment_group_code	`varchar(8)`	Standard X12 group code for the denial.
denial_category	`varchar(32)`	Operational grouping a denial management team works the denial under.

+10 more columns in rcm_denials. The full schema ships with the download.

rcm_appeals· Rows: 1,074

Column	Type	Description
appeal_id	`varchar(24)`	Surrogate key for the appeal.
denial_id	`varchar(24)`	Denial being appealed.
claim_id	`varchar(24)`	Claim under appeal.
payer_id	`varchar(16)`	Payer the appeal was filed with.
appeal_level	`integer`	Appeal level. Level two is filed only after a level one was upheld.
filed_on	`date`	Date the appeal was filed.
decided_on	`date`	Date the payer decided the appeal.

+6 more columns in rcm_appeals. The full schema ships with the download.

rcm_underpayments· Rows: 3,183

Column	Type	Description
underpayment_id	`varchar(24)`	Surrogate key for the underpayment.
charge_id	`varchar(24)`	Charge that was underpaid.
claim_id	`varchar(24)`	Claim the underpaid line sat on.
remittance_id	`varchar(24)`	Remittance that underpaid.
payer_id	`varchar(16)`	Payer that paid below its own contract.
contract_id	`varchar(16)`	Contract the shortfall is measured against.
hcpcs_code	`varchar(8)`	HCPCS Level II code on a professional line.

+9 more columns in rcm_underpayments. The full schema ships with the download.

rcm_patient_statements· Rows: 43,226

Column	Type	Description
statement_id	`varchar(24)`	Surrogate key for the statement.
patient_id	`varchar(16)`	Patient billed.
statement_month	`date`	Billing cycle the statement covers. A patient receives one statement a month, not one per visit.
encounter_count	`integer`	Number of encounters carried on the statement.
statement_balance_usd	`numeric(9,2)`	Balance billed to the patient.
paid_amount_usd	`numeric(9,2)`	Amount the patient paid against the statement.
outstanding_amount_usd	`numeric(9,2)`	Amount left unpaid.

+9 more columns in rcm_patient_statements. The full schema ships with the download.

rcm_collections· Rows: 6,133

Column	Type	Description
collection_id	`varchar(24)`	Surrogate key for the collection placement.
patient_id	`varchar(16)`	Patient whose balance was placed.
statement_id	`varchar(24)`	Statement the balance came from.
placed_amount_usd	`numeric(9,2)`	Amount placed with the agency.
placed_on	`date`	Date of placement, which is also the date the balance leaves provider accounts receivable.
agency_tier	`varchar(24)`	Which agency tier took the placement: primary, secondary or an internal early out unit.
recovered_amount_usd	`numeric(9,2)`	Amount the agency recovered, net of nothing. Zero where nothing came back.

+4 more columns in rcm_collections. The full schema ships with the download.

rcm_write_offs· Rows: 12,455

Column	Type	Description
write_off_id	`varchar(24)`	Surrogate key for the write off.
patient_id	`varchar(16)`	Patient whose balance was written off.
statement_id	`varchar(24)`	Statement the balance came from.
adjustment_type_code	`varchar(24)`	Type of write off: small balance, charity care or bad debt. Small balance and charity care are allowable adjustments and come out of the net collection rate denominator. Bad debt does not, because failing to collect a bill the patient owed is a collection failure and the metric is supposed to show it.
write_off_amount_usd	`numeric(9,2)`	Amount written off.
written_off_on	`date`	Date the write off was taken.
write_off_reason	`varchar(40)`	Why the balance was written off.

+2 more columns in rcm_write_offs. The full schema ships with the download.

rcm_ar_snapshots· Rows: 6,639

Column	Type	Description
ar_snapshot_id	`varchar(24)`	Surrogate key for the snapshot cell.
facility_id	`varchar(16)`	Facility the receivable belongs to.
snapshot_month	`varchar(16)`	Month end the snapshot was taken at.
ar_bucket_code	`varchar(16)`	Ageing bucket, measured in days since the claim was submitted.
open_claim_count	`integer`	Number of claims still open in this bucket at month end.
open_balance_usd	`numeric(10,2)`	Value still open in this bucket at month end. While a claim is with the payer the whole allowed amount is receivable, because the split between payer and patient is not known until the remittance lands.

rcm_monthly_revenue_cycle· Rows: 42

Column	Type	Description
revenue_cycle_month_id	`varchar(16)`	Surrogate key for the monthly scorecard row.
metric_month	`varchar(16)`	Month the metrics cover.
encounter_count	`integer`	Encounters in the month.
charge_count	`integer`	Charge lines posted in the month.
claim_count	`integer`	Claims submitted in the month.
gross_charges_usd	`numeric(11,2)`	Charge master value posted in the month.
net_revenue_usd	`numeric(11,2)`	Contracted allowed value of those charges, which is the real revenue.

+26 more columns in rcm_monthly_revenue_cycle. The full schema ships with the download.

rcm_monthly_payer_performance· Rows: 1,091

Column	Type	Description
payer_month_id	`varchar(24)`	Surrogate key for the payer month row.
payer_id	`varchar(16)`	Payer the metrics cover.
metric_month	`varchar(16)`	Month the metrics cover.
claim_count	`integer`	Claims submitted to this payer in the month.
gross_charges_usd	`numeric(10,2)`	Charge master value billed to this payer.
allowed_amount_usd	`numeric(10,2)`	Contracted allowed value billed to this payer.
contractual_adjustments_usd	`numeric(10,2)`	Contractual adjustment taken against this payer.

+11 more columns in rcm_monthly_payer_performance. The full schema ships with the download.

rcm_monthly_department_metrics· Rows: 10,539

Column	Type	Description
department_month_id	`varchar(24)`	Surrogate key for the department month row.
department_id	`varchar(16)`	Department the metrics cover.
metric_month	`varchar(16)`	Month the metrics cover.
encounter_count	`integer`	Encounters delivered by the department.
charge_count	`integer`	Charge lines raised by the department.
gross_charges_usd	`numeric(10,2)`	Charge master value raised by the department.
net_revenue_usd	`numeric(9,2)`	Contracted allowed value of those charges.

+5 more columns in rcm_monthly_department_metrics. The full schema ships with the download.

rcm_monthly_denial_summary· Rows: 416

Column	Type	Description
denial_month_id	`varchar(24)`	Surrogate key for the denial month row.
denial_code	`varchar(8)`	Claim adjustment reason code.
metric_month	`varchar(16)`	Month the denials were adjudicated in.
denial_count	`integer`	Denials carrying this reason in the month.
denied_amount_usd	`numeric(10,2)`	Allowed value denied under this reason in the month.
share_of_month_denials_pct	`numeric(7,3)`	This reason as a percentage of all denials in the month.
denial_category	`varchar(32)`	Operational grouping the reason is worked under.

+2 more columns in rcm_monthly_denial_summary. The full schema ships with the download.

rcm_payers· Rows: 26

Column	Type	Description
payer_id	`varchar(16)`	Surrogate key for the payer.
payer_name	`varchar(40)`	Payer trading name. The organisation is generated and does not exist.
payer_class	`varchar(16)`	Whether the payer is commercial, government or other.
edi_payer_id	`varchar(8)`	Trading partner identifier claims are routed to on an 837, mirroring the five character payer id used in real electronic claim submission.
payer_domain	`varchar(40)`	Payer website domain. Resolved at build time and discarded if it answered, so no live domain is used.
state_code	`varchar(8)`	State the payer is domiciled in.
claims_po_box	`varchar(16)`	Post office box claims are mailed to when they are not submitted electronically.

+5 more columns in rcm_payers. The full schema ships with the download.

rcm_payer_plans· Rows: 185

Column	Type	Description
plan_id	`varchar(16)`	Surrogate key for the benefit plan.
payer_id	`varchar(16)`	Payer that issues the plan.
payer_type_code	`varchar(24)`	Payer category the plan belongs to.
plan_name	`varchar(64)`	Benefit plan name as it would appear on a member card.
annual_deductible_usd	`integer`	Annual deductible in United States dollars. Zero for Medicaid and workers compensation, which carry none.
coinsurance_rate	`numeric(4,1)`	Share of the allowed amount the member pays after the deductible is satisfied, as a proportion.
office_copay_usd	`integer`	Fixed copayment for an office visit. A copay visit waives the deductible and carries no coinsurance.

+5 more columns in rcm_payer_plans. The full schema ships with the download.

rcm_contracts· Rows: 1,150

Column	Type	Description
contract_id	`varchar(16)`	Surrogate key for the payer to facility contract.
facility_id	`varchar(16)`	Facility the contract covers.
payer_id	`varchar(16)`	Payer the contract is with.
contract_number	`varchar(16)`	Contract reference as it would appear on the agreement.
effective_on	`date`	Date the contract took effect.
expires_on	`date`	Date the contract expires. Empty for an evergreen contract.
term_type	`varchar(16)`	Whether the contract is evergreen, annual or multi year.

+4 more columns in rcm_contracts. The full schema ships with the download.

rcm_contract_rates· Rows: 19,587

Column	Type	Description
contract_rate_id	`varchar(16)`	Surrogate key for the negotiated rate.
contract_id	`varchar(16)`	Contract the rate belongs to.
service_category	`varchar(24)`	Service category the rate prices.
rate_basis	`varchar(24)`	How the rate is expressed: a percentage of Medicare, a fee schedule, a case rate or a per diem.
rate_factor_of_medicare	`numeric(7,4)`	Multiple of the Medicare reference rate payable under this contract for this service category. This is what makes an expected allowed amount computable, and therefore what makes an underpayment visible.
effective_on	`date`	Date the rate took effect.

rcm_facilities· Rows: 71

Column	Type	Description
facility_id	`varchar(16)`	Surrogate key for the facility.
facility_name	`varchar(40)`	Facility name. The organisation is generated and does not exist.
facility_type_code	`varchar(32)`	Facility type.
city_id	`varchar(16)`	City the facility is located in.
state_code	`varchar(8)`	State the facility is located in.
street_address	`varchar(24)`	Street address of the facility.
postal_code	`varchar(8)`	ZIP code, consistent with the state it sits in.

+7 more columns in rcm_facilities. The full schema ships with the download.

rcm_departments· Rows: 318

Column	Type	Description
department_id	`varchar(16)`	Surrogate key for the department.
facility_id	`varchar(16)`	Facility the department sits within.
specialty_code	`varchar(32)`	Clinical specialty the department practises.
department_name	`varchar(48)`	Department name.
cost_centre_code	`varchar(8)`	Cost centre the department reports under in the general ledger.
opened_on	`date`	Date the department opened.

rcm_providers· Rows: 1,139

Column	Type	Description
provider_id	`varchar(16)`	Surrogate key for the provider.
department_id	`varchar(16)`	Department the provider practises in.
facility_id	`varchar(16)`	Facility the provider practises at.
specialty_code	`varchar(32)`	Provider clinical specialty.
provider_npi	`varchar(16)`	National Provider Identifier for the individual. Format correct with a valid Luhn check digit and not a number the NPPES registry has issued.
first_name	`varchar(16)`	Provider first name. The person is generated.
last_name	`varchar(16)`	Provider last name.

+6 more columns in rcm_providers. The full schema ships with the download.

rcm_payer_types· Rows: 10

Column	Type	Description
payer_type_code	`varchar(24)`	Payer category code.
payer_type_name	`varchar(40)`	Payer category name.
payer_class	`varchar(16)`	Whether the category is commercial, government, self pay or other.
covered_lives_share	`numeric(6,3)`	Share of covered lives in this category, as a proportion.
median_days_to_pay	`integer`	Median days from claim submission to payment for this payer category.
baseline_denial_rate	`numeric(6,3)`	Baseline probability that a claim to this payer category is denied, before any claim specific factor.

rcm_denial_reasons· Rows: 15

Column	Type	Description
denial_code	`varchar(8)`	Claim adjustment reason code, combining the X12 group code and the reason number.
adjustment_group_code	`varchar(8)`	Standard X12 claim adjustment group code: CO contractual obligation, PR patient responsibility, OA other adjustment, PI payer initiated reduction.
denial_description	`varchar(80)`	Plain description of the denial reason, written for this dataset rather than reproduced from the licensed code set.
denial_category	`varchar(32)`	Operational grouping a denial management team would work the reason under.
incidence_share	`numeric(6,3)`	Share of denials attributable to this reason, as a proportion.
appeal_overturn_rate	`numeric(5,2)`	Probability that a denial for this reason is overturned when it is worked, whether by rework or by formal appeal.

rcm_claim_statuses· Rows: 11

Column	Type	Description
claim_status_code	`varchar(32)`	Claim status code used throughout the claim lifecycle.
claim_status_name	`varchar(32)`	Claim status name.
status_class	`varchar(24)`	Whether the status is pre submission, in process or closed.
status_order	`integer`	Ordering of the status along the normal claim lifecycle.

rcm_adjustment_types· Rows: 7

Column	Type	Description
adjustment_type_code	`varchar(32)`	Adjustment type code.
adjustment_type_name	`varchar(32)`	Adjustment type name.
adjustment_class	`varchar(24)`	Whether the adjustment is expected, unexpected, administrative or a policy decision.

rcm_ar_buckets· Rows: 6

Column	Type	Description
ar_bucket_code	`varchar(16)`	Accounts receivable ageing bucket, in days since submission.
ar_bucket_name	`varchar(24)`	Ageing bucket name.
bucket_order	`integer`	Ordering of the bucket from newest to oldest.

rcm_icd_codes· Rows: 48

Column	Type	Description
icd10_code	`varchar(16)`	ICD-10-CM diagnosis code as published by CMS and the NCHS.
code_title	`varchar(96)`	Official short title for the code.
chapter_range	`varchar(16)`	ICD-10-CM chapter the code belongs to.
acuity_class	`varchar(16)`	Whether the condition is chronic, acute or preventive in this model.
is_chronic	`varchar(16)`	Y when the code represents an ongoing condition rather than an episode.

rcm_icd_chapters· Rows: 18

Column	Type	Description
chapter_range	`varchar(16)`	ICD-10-CM chapter code range as published, for example I00-I99 for circulatory disease.
chapter_title	`varchar(72)`	Official chapter title.
encounter_share	`numeric(6,3)`	Share of encounters whose principal diagnosis falls in this chapter, as a proportion.

rcm_hcpcs_codes· Rows: 36

Column	Type	Description
hcpcs_code	`varchar(8)`	HCPCS Level II procedure code as published by CMS. CPT is not used in this dataset.
code_description	`varchar(80)`	Official CMS description for the code.
service_category	`varchar(24)`	Grouping used to price the code against a contract and to roll it up for reporting.
medicare_base_rate_usd	`integer`	Medicare reference rate in United States dollars, before any contract factor or regional cost index.
typical_place_of_service	`varchar(8)`	CMS place of service code where this service is most often delivered.

rcm_revenue_codes· Rows: 24

Column	Type	Description
revenue_code	`varchar(8)`	UB-04 revenue code as published by the National Uniform Billing Committee, carried on institutional claims.
revenue_code_description	`varchar(64)`	Official revenue code description.
service_category	`varchar(24)`	Grouping used to price the line against a contract and to roll it up for reporting.
benchmark_allowed_usd	`integer`	Reference allowed amount in United States dollars. Revenue codes carry no national fee schedule, so this is a modelling input rather than a published rate.
applies_to_setting	`varchar(16)`	Encounter setting the code is used in, or any where it is not setting specific.

rcm_place_of_service· Rows: 14

Column	Type	Description
pos_code	`varchar(8)`	CMS place of service code as it appears on a claim.
pos_name	`varchar(64)`	Official place of service description.
setting_class	`varchar(16)`	Broader setting grouping used throughout this dataset.
encounter_share	`numeric(6,3)`	Share of encounters delivered in this place of service, as a proportion.

rcm_specialties· Rows: 22

Column	Type	Description
specialty_code	`varchar(32)`	Clinical specialty code.
specialty_name	`varchar(32)`	Clinical specialty name.
specialty_class	`varchar(16)`	Grouping such as primary care, specialist, surgical, ancillary or behavioral.
provider_share	`numeric(6,3)`	Share of providers practising in this specialty, as a proportion.

rcm_facility_types· Rows: 10

Column	Type	Description
facility_type_code	`varchar(32)`	Facility type code.
facility_type_name	`varchar(40)`	Facility type name.
billing_class	`varchar(16)`	Whether the facility bills institutionally, professionally, as ancillary or as post acute care.

rcm_cities· Rows: 86

Column	Type	Description
city_id	`varchar(16)`	Surrogate key for the city.
city_name	`varchar(24)`	City name.
state_code	`varchar(8)`	State the city sits in.
postal_prefix	`varchar(8)`	Real USPS three digit ZIP prefix that serves this city. Addresses are built from it, so a postal code here is consistent with its city and not merely with its state.
population	`integer`	City population at the 2020 decennial census.
cost_index	`numeric(5,2)`	Relative cost index applied to charges raised in this city.

rcm_states· Rows: 39

Column	Type	Description
state_code	`varchar(8)`	Two letter United States Postal Service state abbreviation.
state_name	`varchar(32)`	Full state name.
population	`integer`	State population at the 2020 decennial census.
cost_index	`numeric(5,2)`	Relative cost index applied to charges in this state, with 1.00 as the national reference.

Sample Data

A snapshot of real rows from the dataset (values are fully synthetic).

claim_id	payer_type_code	claim_form_type	total_charge_usd	total_allowed_usd	total_patient_responsibility_usd	submitted_on	adjudicated_on	claim_status_code	days_to_file
CLM-TB08B9U090	medicare_advantage	837I	15953.52	3815.73	25	2023-08-10		rejected	3
CLM-CXOGRK7MUU	medicare_advantage	837I	3181.16	614.28	0	2025-10-05	2025-10-25	paid	6
CLM-K6D816NVR0	medicaid_managed	837I	509.77	97.42	3	2025-06-03	2025-08-01	partially_paid	5

Version History

v1.0.0	2026-09-01	v1.0.0 - first release. Fifty tables, 1.89 million rows across forty-two months. Registration to cash for a synthetic United States provider: eligibility, authorisation, charge capture, claim submission, remittance, denial, rework, appeal, patient statement and write off. Contracted rates on every line make underpayment against contract computable, and the monthly scorecard reconciles to the transaction tables it is derived from.

Related Datasets

Healthcare Facility and Workforce (SEA)

Healthcare

A Southeast Asian health facility registry and workforce dataset: 9,000 facilities across Indonesia, Malaysia, Singapore, Thailand, the Philippines and Vietnam, ten years of capacity, staffing and utilisation, a full hospital-by-specialty scarcity matrix, and 48 months of facility-level COVID operations data.

$299one time

View details