payroll-gl-reconciliation

name	payroll-gl-reconciliation
description	Reconcile payroll processor reports (Gusto, ADP, Paychex, Rippling) to general ledger journal entries in QuickBooks Online, Xero, or other accounting software. Automates journal entry creation from payroll summaries, validates wage/tax/benefit allocations to correct GL accounts, detects variances, and flags discrepancies before month-end close. Produces audit-ready reconciliation workpapers. Use when: reconciling payroll registers to GL, mapping payroll processor exports to chart of accounts, creating payroll journal entries, validating employee benefit deductions, or preparing payroll workpapers. NOT for: payroll processing or running payroll (use your payroll platform), tax filing (W-2, 941), on-chain payroll (use on-chain-payroll), HR onboarding, or benefits enrollment.
version	1.0.0
author	PrecisionLedger
tags	["payroll","reconciliation","accounting","journal-entries","gl","quickbooks","month-end","compliance"]

Payroll GL Reconciliation Skill

Reconcile payroll processor reports to general ledger journal entries. Automate journal entry creation, validate account mappings, detect variances, and produce audit-ready workpapers — all from raw payroll exports.

---

When to Use This Skill

Trigger phrases:

• "Reconcile payroll to the GL"
• "Create journal entries for payroll"
• "Payroll didn't hit the right accounts"
• "Map Gusto export to QuickBooks"
• "Check payroll entries for month-end close"
• "Payroll reconciliation workpaper"
• "Validate payroll tax liabilities"

NOT for:

• Running or processing payroll — use Gusto, ADP, or Paychex directly
• Filing 941/940/W-2 — use a tax compliance workflow
• On-chain payroll disbursement — use on-chain-payroll skill (PTIN-backed, not here)
• Benefits enrollment or HR workflows — out of scope
• Actual QuickBooks data entry — use qbo-automation for live API writes

---

Payroll GL Reconciliation Overview

Every payroll run produces three categories of GL impact:

1. GROSS WAGES EXPENSE (Debit)
   ├── Regular wages
   ├── Overtime wages
   ├── Bonus / commissions
   └── PTO / sick pay

2. EMPLOYER PAYROLL TAXES EXPENSE (Debit)
   ├── Employer FICA (Social Security 6.2%)
   ├── Employer Medicare (1.45%)
   ├── Federal Unemployment (FUTA 0.6%)
   └── State Unemployment (SUTA — rate varies by state)

3. LIABILITY ACCOUNTS (Credit)
   ├── Net pay payable (cash out → employee bank accounts)
   ├── Employee FICA withheld
   ├── Employee Medicare withheld
   ├── Federal income tax withheld
   ├── State income tax withheld
   ├── Employee benefits deductions (health, dental, 401k)
   └── Employer benefits contributions (401k match, HSA)

The fundamental check:

Total Debits = Gross Wages + Employer Taxes + Employer Benefits
Total Credits = Net Pay + All Withholdings + All Liabilities

Debits must equal Credits. If not, there's an error.

---

Standard Chart of Accounts Mapping

Expense Accounts (Debits)

Payroll Line Item	GL Account	Account Type
Regular wages	6100 – Salaries & Wages Expense	Expense
Overtime pay	6100 – Salaries & Wages Expense	Expense
Bonus / commissions	6110 – Bonus Expense	Expense
Employer FICA	6200 – Payroll Tax Expense	Expense
Employer Medicare	6200 – Payroll Tax Expense	Expense
FUTA	6210 – Federal Unemployment Tax Expense	Expense
SUTA	6220 – State Unemployment Tax Expense	Expense
Employer 401(k) match	6300 – Employee Benefits Expense	Expense
Employer health premium	6310 – Health Insurance Expense	Expense
Employer HSA contribution	6320 – HSA Contribution Expense	Expense

Liability Accounts (Credits)

Payroll Line Item	GL Account	Account Type
Net pay to employees	2000 – Net Payroll Payable	Current Liability
Employee FICA withheld	2100 – FICA Payable	Current Liability
Employee Medicare withheld	2110 – Medicare Payable	Current Liability
Federal income tax withheld	2120 – Federal Withholding Payable	Current Liability
State income tax withheld	2130 – State Withholding Payable	Current Liability
Employee 401(k) deduction	2200 – 401(k) Payable	Current Liability
Employee health deduction	2210 – Health Insurance Payable	Current Liability
Employer FICA (matching)	2100 – FICA Payable	Current Liability
Employer Medicare (matching)	2110 – Medicare Payable	Current Liability

Note: When taxes are remitted to the IRS/state, debit the liability account and credit cash.

---

Department / Cost Center Allocation

For multi-department businesses, allocate wages by department:

6100 – Wages Expense (Engineering)    [Debit]    $45,000
6100 – Wages Expense (Sales)          [Debit]    $30,000
6100 – Wages Expense (G&A)            [Debit]    $25,000

Allocation methods:

1. Direct mapping — each employee assigned a department in payroll system
2. Headcount ratio — allocate shared costs proportionally
3. Time tracking — allocate based on logged hours per project/department
4. Revenue ratio — allocate shared overhead by revenue contribution

---

Processor-Specific Export Formats

Gusto

Gusto provides a "Payroll Journal" CSV export under Reports → Journal Entries.

import csv
from dataclasses import dataclass
from typing import List

@dataclass
class GustoPayrollLine:
    pay_date: str
    employee_name: str
    department: str
    gross_wages: float
    employee_fica: float
    employee_medicare: float
    federal_withholding: float
    state_withholding: float
    employee_401k: float
    employee_health: float
    net_pay: float
    employer_fica: float
    employer_medicare: float
    futa: float
    suta: float
    employer_401k: float
    employer_health: float

def parse_gusto_export(filepath: str) -> List[GustoPayrollLine]:
    """
    Parse Gusto payroll journal CSV into structured records.
    
    Gusto columns (may vary by plan):
    'Check Date', 'Employee Name', 'Department', 'Gross Pay',
    'Employee OASDI', 'Employee Medicare', 'Federal WH', 'State WH',
    '401k Employee', 'Medical Employee', 'Net Pay',
    'Employer OASDI', 'Employer Medicare', 'FUTA', 'SUTA',
    '401k Employer', 'Medical Employer'
    """
    lines = []
    with open(filepath, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            lines.append(GustoPayrollLine(
                pay_date=row.get('Check Date', ''),
                employee_name=row.get(, ),
                department=row.get(, ),
                gross_wages=(row.get(, )  ),
                employee_fica=(row.get(, )  ),
                employee_medicare=(row.get(, )  ),
                federal_withholding=(row.get(, )  ),
                state_withholding=(row.get(, )  ),
                employee_401k=(row.get(, )  ),
                employee_health=(row.get(, )  ),
                net_pay=(row.get(, )  ),
                employer_fica=(row.get(, )  ),
                employer_medicare=(row.get(, )  ),
                futa=(row.get(, )  ),
                suta=(row.get(, )  ),
                employer_401k=(row.get(, )  ),
                employer_health=(row.get(, )  ),
            ))
     lines

ADP

ADP exports vary by product (RUN, Workforce Now, TotalSource). Request the "Payroll Register" + "Tax Summary" reports.

def parse_adp_register(filepath: str) -> dict:
    """
    Parse ADP payroll register. ADP uses fixed-width or pipe-delimited format.
    
    Key ADP column names:
    'Employee Name', 'Reg Hours', 'Reg Earn', 'OT Earn', 'Gross',
    'FIT', 'SIT', 'SS EE', 'MED EE', 'SS ER', 'MED ER',
    '401K EE', '401K ER', 'Medical EE', 'Medical ER',
    'Net Pay', 'FUTA', 'SUI'
    """
    # ADP format detection
    with open(filepath, 'r') as f:
        header = f.readline()
    
    delimiter = '|' if '|' in header else ','
    # ... parse with detected delimiter
    pass

Paychex

def parse_paychex_summary(filepath: str) -> dict:
    """
    Paychex Payroll Summary Report.
    Download from: My Paychex → Reports → Payroll Summary
    
    Key sections in Paychex report:
    - 'Earnings' block: Regular, Overtime, Bonus
    - 'Employee Deductions' block: FIT, SIT, FICA, Medicare, Benefits
    - 'Employer Taxes' block: FUTA, SUTA, FICA ER, Medicare ER
    - 'Employer Benefits': 401k Match, Health ER
    - 'Check Summary': Net Pay total
    """
    pass

---

Journal Entry Builder

from dataclasses import dataclass, field
from typing import List
from decimal import Decimal, ROUND_HALF_UP

@dataclass
class JournalLine:
    account_number: str
    account_name: str
    debit: Decimal = Decimal('0')
    credit: Decimal = Decimal('0')
    memo: str = ''
    department: str = ''

@dataclass
class JournalEntry:
    date: str
    reference: str
    description: str
    lines: List[JournalLine] = field(default_factory=list)
    
    @property
    def total_debits(self) -> Decimal:
        return sum(line.debit for line in self.lines)
    
    @property
    def total_credits(self) -> Decimal:
        return sum(line.credit for line in self.lines)
    
    @property
    def is_balanced(self) -> bool:
        return (.total_debits - .total_credits) < Decimal()
    
     () -> :
        
        errors = []
          .is_balanced:
            errors.append(
                
                
            )
          .lines:
            errors.append()
         i, line  (.lines):
             line.debit >   line.credit > :
                errors.append()
         errors


 () -> JournalEntry:
    
    
    
    accounts = {
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
        : (, ),
    }
     account_map:
        accounts.update(account_map)
    
    
    totals = {
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
        : Decimal(),
    }
    
     line  lines:
        totals[] += Decimal((line.gross_wages))
        totals[] += Decimal((line.employer_fica))
        totals[] += Decimal((line.employer_medicare))
        totals[] += Decimal((line.futa))
        totals[] += Decimal((line.suta))
        totals[] += Decimal((line.employer_401k))
        totals[] += Decimal((line.employer_health))
        totals[] += Decimal((line.net_pay))
        totals[] += Decimal((line.employee_fica))
        totals[] += Decimal((line.employee_medicare))
        totals[] += Decimal((line.federal_withholding))
        totals[] += Decimal((line.state_withholding))
        totals[] += Decimal((line.employee_401k))
        totals[] += Decimal((line.employee_health))
    
    je = JournalEntry(
        date=pay_date,
        reference=,
        description=,
        lines=[]
    )
    
     ():
         amount > :
            num, name = accounts[key]
            je.lines.append(JournalLine(
                account_number=num, account_name=name,
                debit=amount.quantize(Decimal(), rounding=ROUND_HALF_UP),
                memo=memo  je.description
            ))
    
     ():
         amount > :
            num, name = accounts[key]
            je.lines.append(JournalLine(
                account_number=num, account_name=name,
                credit=amount.quantize(Decimal(), rounding=ROUND_HALF_UP),
                memo=memo  je.description
            ))
    
    
    add_debit(, totals[], )
    add_debit(, totals[] + totals[], )
    add_debit(, totals[], )
    add_debit(, totals[], )
    add_debit(, totals[], )
    add_debit(, totals[], )
    
    
    add_credit(, totals[], )
    add_credit(, totals[] + totals[], )
    add_credit(, totals[] + totals[], )
    add_credit(, totals[], )
    add_credit(, totals[], )
    add_credit(, totals[] + totals[], )
    add_credit(, totals[] + totals[], )
    
     je

---

Variance Detection & Reconciliation Checks

def reconcile_payroll_to_gl(
    payroll_je: JournalEntry,
    gl_actual: dict,
    tolerance_usd: float = 0.10
) -> dict:
    """
    Compare expected journal entry (from payroll export) vs actual GL entries.
    
    Args:
        payroll_je: Journal entry built from payroll processor data
        gl_actual: Dict of {account_number: actual_amount} from GL export
        tolerance_usd: Acceptable rounding variance (default $0.10)
    
    Returns:
        Reconciliation result with variances and pass/fail flags
    """
    variances = []
    
    for line in payroll_je.lines:
        expected = float(line.debit or line.credit)
        actual = gl_actual.get(line.account_number, 0)
        diff = abs(expected - actual)
        
        if diff > tolerance_usd:
            variances.append({
                'account': f"{line.account_number} – {line.account_name}",
                'expected': expected,
                'actual': actual,
                'variance': actual - expected,
                'variance_pct': (actual - expected) / expected * 100 if expected else None,
                'flag': 'MATERIAL' if diff > 100 else 'MINOR'
            })
    
    return {
        'reconciled': len(variances) == 0,
        'material_variances': [v for v in variances  v[] == ],
        : [v  v  variances  v[] == ],
        : (v[]  v  variances),
        : ([v  v  variances  v[] == ]) > 
    }


 () -> :
    
    causes = {
        : [
            ,
            ,
            ,
        ],
        : [
            ,
            ,
            ,
        ],
        : [
            ,
            ,
        ],
        : [
            ,
            ,
        ],
        : [
            ,
            ,
            ,
        ],
    }
     causes.get(account, [])

---

Workpaper Output Format

Reconciliation Workpaper (Markdown)

def generate_workpaper(
    je: JournalEntry,
    recon_result: dict,
    processor: str,
    client_name: str
) -> str:
    """Generate audit-ready reconciliation workpaper in markdown."""
    
    balanced_status = "✅ BALANCED" if je.is_balanced else "❌ UNBALANCED"
    recon_status = "✅ RECONCILED" if recon_result['reconciled'] else "⚠️ VARIANCES FOUND"
    
    lines_table = "\n".join([
        f"| {l.account_number} | {l.account_name} | "
        f"${l.debit:,.2f} | ${l.credit:,.2f} | {l.memo} |"
        for l in je.lines
    ])
    
    return f"""
# Payroll GL Reconciliation Workpaper
**Client:** {client_name}
**Pay Date:** {je.date}
**Period:** {je.description}
**Payroll Processor:** {processor}
**Prepared by:** Sam Ledger / PrecisionLedger
**Date Prepared:** {datetime.today().strftime('%Y-%m-%d')}

---

## Journal Entry — {balanced_status}

| Account # | Account Name | Debit | Credit | Memo |
|-----------|-------------|-------|--------|------|
{lines_table}
| | **TOTALS** | **${je.total_debits:,.2f}** | **${je.total_credits:,.2f}** | |

---

## GL Reconciliation — {recon_status}

{ 
  recon_result[] 
  }




---

## Sign-Off

- [ ] Journal entry reviewed for accuracy
- [ ] GL accounts agree to payroll register totals
- [ ] All variances investigated and resolved
- [ ] Journal entry posted in accounting system
- [ ] Payroll register filed in client workpaper folder

**Reviewer:** _________________ **Date:** _________________
"""

---

Step-by-Step Workflow

Monthly Payroll Close Checklist

For each payroll run in the period:

□ 1. EXPORT from payroll processor
     - Gusto: Reports → Journal Entries → CSV
     - ADP: Reports → Payroll Register + Tax Summary
     - Paychex: My Paychex → Reports → Payroll Summary

□ 2. PARSE the export
     - Run through appropriate parser function above
     - Verify employee count and period match expectations

□ 3. BUILD journal entry
     - Use build_payroll_journal_entry()
     - Confirm balanced (debits = credits)
     - Map to client's specific chart of accounts

□ 4. COMPARE to GL
     - Export actual GL entries for payroll accounts
     - Run reconcile_payroll_to_gl()
     - Investigate any variance > $100

□ 5. DOCUMENT variances
     - Root-cause each material variance
     - Prepare adjusting entries if needed
     - Note minor variances with explanation

□ 6. GENERATE workpaper
     - Run generate_workpaper()
     - Save as PDF in client workpaper folder
     - Include original payroll register as support

□ 7. POST to accounting system
     - Via QBO API (use qbo-automation skill) or manual entry
     - Confirm posting with journal entry reference number

□ 8. VERIFY tax liability balances
     - FICA Payable balance = this period + any prior unpaid
     - 941 semi-weekly vs monthly deposit schedule
     - State withholding deposit due dates by state

---

Tax Deposit Schedule Reference

Tax Type	Federal Deposit Schedule	2026 Rates
Federal income tax withheld	Semi-weekly or monthly*	Varies per W-4
Employee FICA (SS)	Same as FIT	6.2% (up to $176,100 wage base)
Employer FICA	Same as FIT	6.2%
Employee Medicare	Same as FIT	1.45% (+ 0.9% over $200k)
Employer Medicare	Same as FIT	1.45%
FUTA	Quarterly if liability > $500	0.6% (up to $7,000 wage base)
SUTA	Varies by state	Varies (avg ~2.7%)

*Semi-weekly: payroll Wednesday/Thursday → deposit by following Wednesday; payroll Fri/Sat/Sun/Mon/Tue → deposit by following Friday *Monthly: deposit by 15th of following month (if prior year tax liability < $50,000)

---

Integration Points

• qbo-automation — post journal entries via QBO API after reconciliation
• financial-close-checklist — payroll recon is a required step in monthly close
• compliance-monitor — track 941 and state tax deposit deadlines
• crypto-tax-agent — if employee equity/token compensation involved
• bank-reconciliation-agent — confirm net payroll matches bank ACH outflow

---

Example: End-to-End Reconciliation

Input: Gusto export, 15 employees, pay period March 1-15, 2026

Sam receives: gusto_payroll_2026-03-15.csv

Step 1: parse_gusto_export('gusto_payroll_2026-03-15.csv')
  → 15 employee records parsed
  → Total gross wages: $87,450.00

Step 2: build_payroll_journal_entry(lines, '2026-03-15', 'March 1-15, 2026')
  → Journal Entry PR-20260315
  → Total debits: $101,247.83
  → Total credits: $101,247.83
  → Status: BALANCED ✅

Step 3: reconcile_payroll_to_gl(je, qbo_gl_extract)
  → Account 6100 Wages: Expected $87,450 | Actual $87,450 ✅
  → Account 2100 FICA: Expected $10,842.90 | Actual $10,842.90 ✅
  → Account 2000 Net Pay: Expected $62,114.50 | Actual $62,190.00 ⚠️
    Variance: +$75.50 → Investigate (likely off-cycle check not in register)

Step 4: generate_workpaper(...)
  → Saved: workpapers/PR-20260315-recon.md
  → 1 minor variance flagged for review
  → All major accounts reconcile within tolerance

---

Common Errors & Fixes

Error	Likely Cause	Fix
JE doesn't balance	Rounding on individual lines	Use Decimal, not float
FICA payable too low	SS wage base hit for high earners	Check individual wage bases
Net pay variance	Off-cycle check or reversal	Search bank feed for extra ACH
Benefits mismatch	Mid-period enrollment change	Compare to benefits carrier invoice
SUTA variance	Rate update not in system	Confirm current year SUTA rate
Missing department	Employee dept not set in payroll	Default to 'General', flag for setup