For any finance team operating across multiple entities, intercompany reconciliation is a monthly ritual of pain. The process typically involves exporting ledgers from multiple ERP systems, wrestling with mismatched currency conversions, hunting down missing invoices, and chasing business units for explanations on unexplained variances. Controllers and financial analysts spend days—sometimes weeks—manually matching transactions that should balance, only to find that a single misclassified entry in one subsidiary creates a cascading set of reconciling items that require manual journal entries to correct. The sheer volume of data, combined with the need for precision, makes this one of the most dreaded tasks in the close calendar.
Claude Code changes this dynamic fundamentally. Rather than replacing the finance team, it acts as a tireless analytical assistant that can ingest large volumes of intercompany transaction data, apply your specific matching rules, flag exceptions in real time, and generate a fully documented reconciliation package. The key is not that Claude does the thinking for you—it is that Claude does the reading, sorting, comparing, and documenting that consumes 80% of your analysts’ time. By structuring your prompts correctly, you can turn Claude Code into a specialist that understands your entity mappings, your tolerance thresholds, and your reporting format, producing output that is audit-ready and consistent with your internal controls.
The practical result is a reduction in reconciliation time from days to hours, with a dramatic drop in human error. Instead of your team manually copying figures between spreadsheets, they review Claude’s work, investigate flagged exceptions, and sign off on a process that is both faster and more transparent. Below are two structured prompts you can adapt immediately for your own intercompany reconciliation workflow using Claude Code.
Bridging the Gap Between Raw Data and Clean Reconciliation
Before you begin, understand that Claude Code works best when you provide it with clear context and structured data. You will need to export your intercompany transaction files from your ERP systems—typically as CSV or Excel files—and save them in a folder that Claude Code can access. You will also need a copy of your intercompany agreements or transfer pricing policies, as these define the rules for matching and adjustment. The prompts below are designed to be used sequentially: the first one builds the initial reconciliation, the second one handles exception resolution and documentation.
First, read these files completely before responding:
entity_balances.csv — contains ending balances for all intercompany accounts by entity and counterparty for the current month
transaction_detail_uk.xlsx — contains all UK subsidiary intercompany transactions with dates, amounts, counterparty references, and currency (GBP)
transaction_detail_de.xlsx — contains all Germany subsidiary intercompany transactions with dates, amounts, counterparty references, and currency (EUR)
intercompany_agreements.pdf — contains our transfer pricing policies, settlement terms, and currency conversion rules
Here is a reference for what I want to achieve:
I have attached a sample reconciliation file (sample_recon_format.csv) from last quarter that shows the exact layout my controller expects: columns for Entity, Counterparty, Account Code, Transaction Date, Original Amount, Original Currency, Converted Amount (USD), Matching Status, and Notes.
Here’s what makes this reference work:
The reference uses a consistent matching key of (Counterparty + Account Code + Transaction Date within 2 business days + Amount within 1% tolerance)
Currency conversion uses the month-end spot rate from our treasury system, not the daily rate
Any transaction that does not match on the first pass is flagged as “Unmatched” and requires a manual review note
The final output is sorted by Entity, then by Counterparty, then by Transaction Date
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: A CSV file with the same columns as the reference, containing all transactions from both subsidiaries and the US parent, with a summary tab showing total matched, unmatched, and variance amounts per entity pair.
Recipient’s reaction: My controller should be able to open the file and immediately see which items need investigation, without having to re-sort or re-calculate anything.
Does NOT sound like: A generic list of transactions with no analysis. I do not want just a dump of data; I need the matching logic applied and clear flags for exceptions.
Success means: At least 85% of transactions are automatically matched on the first pass, and all unmatched items have a reason code (e.g., “Date mismatch”, “Amount variance > 1%”, “Missing counterparty”).
My context file (finance_standards.md) contains my materiality thresholds, audit requirements, and preferred naming conventions. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
This first prompt is designed to get Claude Code to act as a structured data analyst. Note the emphasis on reading the reference file and extracting the matching rules from it—this is what ensures consistency with your existing reporting. The success criteria are explicit and measurable, which forces Claude to produce output that you can actually use without significant manual rework. The instruction to ask clarifying questions before starting is crucial; it prevents Claude from making incorrect assumptions about your data structures or tolerance levels.
Handling Exceptions and Generating Audit Documentation
Once you have the initial reconciliation output, the next challenge is dealing with the exceptions. In a typical month, you will have 10-15% of transactions that do not match on the first pass. These require investigation—checking if a transaction was posted in the wrong period, if a currency conversion was applied incorrectly, or if one entity simply forgot to book an invoice. The following prompt focuses on turning Claude Code into an exception investigator that can trace the underlying causes, suggest corrective journal entries, and draft the documentation required for your audit trail.
First, read these files completely before responding:
reconciliation_output.csv — the file generated from the first pass reconciliation, containing columns for Entity, Counterparty, Account Code, Transaction Date, Amount, Currency, Matching Status, and Reason Code
unmatched_transactions.xlsx — a separate sheet containing only the unmatched items, with additional columns for internal notes from business unit controllers
journal_entry_template.docx — the standard template our team uses for corrective entries, with fields for account, debit, credit, and approval signature
Here is a reference for what I want to achieve:
I have attached a folder called “prior_month_resolutions” containing three examples of how we resolved similar unmatched items last quarter. Each example includes the investigation notes, the corrective journal entry, and the final sign-off.
Here’s what makes this reference work:
Each resolution follows a logical structure: (1) Identify the root cause, (2) State the evidence found, (3) Propose the corrective entry, (4) Note the impact on the intercompany balance
Common root causes are: timing differences (goods in transit, invoices in process), currency rounding differences, and duplicate postings
All corrective entries must be approved by both entity controllers before posting
The documentation is written in a neutral, factual tone with specific reference numbers
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: For each unmatched transaction, a one-page resolution memo in the same format as the reference examples. Additionally, a summary email draft to both controllers listing the proposed entries and requesting their approval.
Recipient’s reaction: My audit manager should be able to read each memo and understand exactly why the mismatch occurred and what we are doing to fix it, without needing to ask follow-up questions.
Does NOT sound like: Generic statements like “investigation pending” or “will follow up.” I need concrete analysis based on the data in the files provided.
Success means: All unmatched items are categorized into one of five root cause buckets, and at least 90% have a proposed corrective entry that we can post immediately upon approval.
My context file (audit_protocol.md) contains our documentation standards, required sign-off levels, and file naming conventions. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
This second prompt is where the real value lies for controllers. By forcing Claude to follow the structure of your prior resolutions, you ensure that the output is not just technically correct but also stylistically consistent with what your audit team has seen before. The requirement to produce a summary email draft is a practical touch—it means the output is immediately actionable, not just an analysis sitting in a folder. The success criteria around root cause categorization and percentage of proposed entries give you a clear metric to evaluate whether Claude has done the job properly.
One practical tip when using these prompts: start with a small subset of data—perhaps one entity pair or one month of transactions—before running the full reconciliation. This allows you to verify that Claude’s matching logic aligns with your expectations and that the output format is exactly what your team needs. Adjust the tolerance levels and matching keys in the prompt based on what you see in the first run. Also, be explicit about your materiality threshold; if you only care about variances above $1,000, state that clearly in the prompt so Claude does not waste time on insignificant rounding differences.
What to try next: once you have the reconciliation working smoothly, extend the same prompt structure to other close activities—bank reconciliations, fixed asset roll-forwards, or intercompany settlement confirmations. The anatomy of the prompt—define the task, provide reference material, extract the rules, specify success criteria, and require a plan—is reusable across virtually any analytical finance task. The more you use it, the faster your team will become at turning raw data into decision-ready information.
Published on 31 August 2026 on growwithgpt.com