Using LLMs to Automate and Enhance Bookkeeping with Beancount

Beancount is a plain-text double-entry accounting system that has recently become more accessible thanks to large language models (LLMs) like ChatGPT. Technical users – including business owners, startup founders, engineers, and accountants – can leverage LLMs to automate tedious bookkeeping tasks while maintaining the flexibility and transparency of Beancount’s text-based ledger. This report explores practical ways LLMs can streamline Beancount workflows, including transaction categorization, anomaly detection, smart suggestions for journal entries, generating entries from natural language, and reconciling statements. Example prompts and outputs are provided to illustrate these capabilities, along with implementation tips, existing tools, and a discussion of opportunities and limitations.

Automated Transaction Categorization with LLMs

One of the most time-consuming aspects of bookkeeping is categorizing transactions (assigning them to the correct accounts) based on descriptors like payee, memo, or amount. LLMs can significantly accelerate this by using their language understanding and broad knowledge to suggest appropriate expense or income accounts for each transaction.

For example, if your Beancount ledger has an uncategorized entry:

2023-02-28 * "Amazon.com" "Laptop Stand, ... Portable Notebook Stand..."
   Assets:Zero-Sum-Accounts:Amazon-Purchases   -14.29 USD
   (missing expense account)

A prompt to an LLM could ask for a suitable expense account to balance the transaction. In one real case, an LLM categorized an Amazon purchase of a laptop stand as Expenses:Office-Supplies:Laptop-Stand. Similarly, it assigned a wiper blade purchase to Expenses:Car:Maintenance and a kitchen appliance to Expenses:Kitchen:Appliances, intelligently inferring categories from the item descriptions. These examples show how an LLM can use context (the payee and description) to pick an appropriate Beancount account.

Modern tools like Beanborg integrate this capability: Beanborg is an open-source Beancount importer that can automatically match transaction data to the correct expense accounts. It primarily uses a rules-based engine, but also supports machine learning and even ChatGPT for categorization suggestions. With Beanborg, you can import a bank CSV and get most entries auto-classified (e.g., a payee containing "Fresh Food Inc." might be categorized under Expenses:Groceries by rules or LLM assistance).

How to use an LLM for categorization: You could feed a batch of transaction descriptions to a model like GPT-4 and ask it to assign likely accounts. One suggested workflow is: use GPT to categorize a small batch of expenses, correct any mistakes manually, then use Beancount’s built-in importer plugins (like smart_importer) to learn from those examples for future transactions. This hybrid approach leverages the LLM’s broad knowledge for new or uncommon transactions (for instance, inferring that PILOT Parallel Calligraphy Pens should fall under an Art Supplies expense account) and then applies those categorizations consistently going forward.

Example Prompt & Response: The table below shows how a user might interact with an LLM to categorize transactions:

User Prompt (transaction details)	LLM Suggested Account/Entry
Categorize: "Starbucks - Latte $5.00 on 2025-04-01"	Suggestion: Expense – likely Expenses:Food:Coffee (coffee purchase)
Categorize: "Amazon.com - Bosch Rear Wiper Blade $11.60"	Suggestion: Expenses:Car:Maintenance (car part replacement)
Categorize: "Salary payment from ACME Corp $5000"	Suggestion: Income:Salary (paycheck income)
Complete Entry: 2025-07-10 * "Office Depot" "printer ink" Assets:Checking -45.00 USD	Adds: Expenses:Office:Supplies 45.00 USD (balance the entry)

In these examples, the LLM draws on general knowledge (Starbucks is coffee, Amazon car parts relate to auto maintenance, ACME salary is income) to propose the correct Beancount account. It can even complete a journal entry by adding the missing balancing posting (in the Office Depot case, suggesting an Office Supplies expense account to offset the payment). Over time, such AI-driven categorization can save time and reduce manual effort in classifying transactions.

Anomaly Detection and Duplicate Identification

Beyond categorization, LLMs can help flag anomalies in the ledger – such as duplicate entries or unusual expenses – by analyzing transaction descriptions and patterns in plain English. Traditional software might catch exact duplicates via hashes or strict rules (for example, Beanborg uses a hash of CSV data to prevent importing the same transaction twice). An LLM, however, can provide a more context-aware review.

For instance, you could prompt an LLM with a list of recent transactions and ask: “Do any of these look like duplicates or unusual outliers?” Because LLMs excel at contextual analysis, they might notice if two entries have the same date and amount, or very similar descriptions, and flag them as potential duplicates. They can also recognize patterns of normal spending and spot deviations. As one source notes, “in the context of a financial transaction stream, an LLM can detect abnormal spending habits” by learning what’s typical and identifying what doesn’t fit.

Unusual amount example: If you usually spend $30–$50 on fuel, but suddenly one fuel transaction is $300, an LLM could highlight that as an anomaly (“this fuel expense is ten times larger than your usual pattern”). LLMs identify anomalies by detecting even subtle deviations that rule-based systems might overlook. They consider the context – e.g., the timing, category, frequency – rather than just hard thresholds.

Duplicate example: Given two ledger lines that are nearly identical (same payee and amount on close dates), an LLM could respond: “The transactions on 2025-08-01 and 2025-08-02 for $100 to ACME Corp appear to be duplicates.” This is especially useful if data was entered from multiple sources or if a bank double-posted a transaction.

While LLM-driven anomaly detection is still an emerging area, it complements traditional methods by explaining why something is flagged in natural language. This can help a human reviewer quickly understand and address the issue (for example, confirming a duplicate and deleting one entry, or investigating an outlier expense).

Smart Suggestions for Journal Completion

LLMs can act as intelligent assistants when you’re composing or correcting journal entries in Beancount. They not only categorize transactions, but also suggest how to complete partial entries or correct imbalances. This is like having a smart autocompletion for your ledger.

Account and amount suggestions: Suppose you input a new transaction with the payee and amount but haven’t decided which account it belongs to. An LLM can suggest the account based on the description (as covered in categorization). It can also ensure the entry balances by supplying the complementary posting. For example, a user might write:

2025-09-10 * "Cloud Hosting Inc" "Monthly VM hosting fee"
   Assets:Bank:Checking        -120.00 USD
   [Missing second posting]

By asking the LLM, “What’s the other side of this transaction?”, it might suggest: Expenses:Business:Hosting 120.00 USD to balance the entry, recognizing that a cloud hosting fee is a business expense.

In the Beancount Google Group, one user demonstrated this by feeding a batch of one-sided Amazon purchase entries to ChatGPT and prompting it to “add categorized expense postings to balance each transaction”. GPT filled in each missing posting with a plausible expense account (albeit sometimes too granular, like creating an account just for “Laptop Stand”). This showcases how LLMs can draft complete journal entries when given incomplete data.

Narration improvements: LLMs can even help improve the narration or descriptions in entries. If a description is too cryptic (e.g., an internal code from a bank statement), you could ask the LLM to rewrite it more clearly for the ledger. Since LLMs handle natural language well, they might transform “PUR CHK 1234 XYZ CORP” into “Check #1234 to XYZ Corp” for clarity.

Guidance and learning: Over time, an LLM could be integrated into your editing workflow (possibly via an editor plugin or Fava extension) to suggest likely completions as you type a transaction. This is analogous to how code editors use AI to suggest code completions. In plain-text accounting, the LLM can draw from your existing account names and past entries to recommend how to finalize the next one. For example, if you frequently record Office Supplies when “Staples” appears in the payee, the model can learn this pattern. Some users report that ChatGPT’s suggestions can be refined after a few examples and then generalized using a plugin like smart_importer for future transactions.

In summary, LLMs provide a “second pair of eyes” on your entries, offering completions and corrections that adhere to Beancount’s double-entry rules.

Generating Beancount Entries from Unstructured Inputs

Perhaps one of the most powerful uses of LLMs is translating unstructured financial information – raw text, receipts, or natural language descriptions – into structured Beancount entries. This allows users to speak or paste free-form data and get valid ledger entries in return.

From natural language to entry: You can prompt an LLM with a sentence like,

“I bought office supplies (printer ink) from Office Depot for $45 on July 10, 2025, paid with my checking account.”

A capable LLM will interpret this and produce something like:

2025-07-10 * "Office Depot" "printer ink"
   Assets:Bank:Checking        -45.00 USD
   Expenses:Office:Supplies     45.00 USD

It has identified the date, payee, narration, amount, and guessed the appropriate accounts (crediting the bank asset, debiting an office supplies expense). This essentially turns a plain English expense report into a properly formatted Beancount journal entry. Recent research has even used Beancount as a target format to evaluate LLMs’ understanding of double-entry accounting, with mixed results (LLMs often need careful prompting to get the syntax exactly right). With a well-crafted prompt or few-shot examples, however, models like GPT-4 can usually produce a correct entry for simple scenarios.

OCR to ledger: LLMs with vision or OCR capabilities (like GPT-4 with image input, or specialized tools) can go a step further: take an image of a receipt or a PDF of a bank statement and extract transactions from it. For example, you might show ChatGPT a photo of a receipt and ask for a Beancount entry – the model would parse the date, total, vendor, and perhaps tax, then output the entry with those details. One guide notes that ChatGPT can convert data from invoices or receipts into “clean, formatted tables suitable for accounting”, which you could then map to Beancount accounts. Similarly, a CSV or Excel export can be fed to an LLM with instructions to output Beancount transactions – indeed, users have prompted GPT to “write a Python script to parse a CSV and output Beancount entries” as a way of automating imports.

Multi-transaction processing: LLMs can handle batch inputs as well. You could paste a list of raw transactions (dates, descriptions, amounts) and request the model to generate corresponding Beancount ledger lines. An example prompt from the community uses a detailed instruction for GPT-4 to “convert the CSV content to Beancount format” while following accounting principles. The output is a complete .beancount file covering all transactions. This approach essentially allows non-programmers to achieve what custom import scripts would do – by instructing the AI in natural language.

Keep in mind that while LLMs are impressive at parsing and generating text, validation is crucial. Always review the entries produced from unstructured inputs. Check dates, amounts, and that the debits/credits balance (Beancount’s compiler will catch imbalance errors). As one study highlighted, without careful guidance an LLM might only produce fully correct double-entry transactions a small fraction of the time. Providing template examples in your prompt and explicitly reminding the model of Beancount syntax will greatly improve accuracy.

Reconciling Statements with LLM Assistance

Bank reconciliation – the process of matching your ledger against an external statement (bank or credit card) – can be tedious. LLMs can act as intelligent comparison engines, helping to identify discrepancies between your Beancount records and the statement.

Identifying missing or mismatched entries: A straightforward use case is to give the LLM two lists: one of transactions from your ledger for a period, and one from the bank statement, then ask it to find which entries don’t match. Because the model can read and compare line by line, it will highlight items present in one list and not the other. For example, you can prompt: “Here is my ledger for March and my bank’s March statement. Which transactions are on the statement but not in my ledger, or vice versa?”. A guide on using ChatGPT in bookkeeping notes: “Paste a list of transactions, and ChatGPT highlights missing or mismatched entries.”. This means the AI might output something like: “The payment of 120.00 USD on 03-15 appears on the bank statement but is not in the ledger (possible missing entry).”

Explaining differences: LLMs can also describe differences in plain language. If a transaction has a different amount or date between the ledger and statement (perhaps due to a typo or timing difference), the LLM can flag: “Transaction X has $105 in ledger vs $150 on bank statement – these may refer to the same item with an amount discrepancy.” This natural explanation can guide you directly to the issue to fix, instead of you manually scanning lines of numbers.

Automating reconciliation workflows: In practice, you might use ChatGPT’s Advanced Data Analysis (formerly Code Interpreter) feature: upload your statement CSV and maybe your ledger export, and let it programmatically cross-check them. There are also emerging plugins and tools focusing on reconciliation. For instance, some have demonstrated ChatGPT preparing reconciliation reports and even suggesting adjusting journal entries to balance the books. While these are early-stage experiments, they point to a future where much of the grunt work in reconciliation (comparisons, highlighting differences) is offloaded to an AI, and the human bookkeeper just reviews and approves adjustments.

It’s important to maintain control and security when using LLMs for reconciliation, especially with sensitive financial data. If using cloud-based models, ensure no account numbers or personal identifiers are shared, or use anonymized data. An alternative is running a local LLM (discussed below) so the data never leaves your environment.

Implementation Methods: APIs, Workflows, and Tools

How can one practically integrate LLMs into a Beancount-based workflow? There are several approaches, ranging from simple copy-paste interactions with ChatGPT to building custom automated pipelines:

• Manual Prompting (ChatGPT UI): The most accessible method is to use ChatGPT (or another LLM interface) interactively. For example, copy a batch of uncategorized transactions and prompt the model for categories. Or paste a chunk of a bank statement and ask for Beancount conversion. This requires no coding – as evidenced by many users who simply describe their problem to ChatGPT and get usable results. The downside is that it’s a bit ad-hoc and you must ensure the model is guided well each time.

• APIs and Scripting: For a more repeatable workflow, you can use an API (such as OpenAI’s API for GPT-4) to process transactions. This could be done in a Python script that reads new transactions and calls the API to get a category suggestion or a full entry. You might integrate this with your import pipeline. For instance, Beanborg’s configuration allows enabling ChatGPT suggestions by setting use_llm: true and providing an API key. Then each imported transaction gets an extra category prediction from GPT alongside the rule-based or ML prediction, which you can review.

• Plugins and Extensions: As LLMs gain popularity, we can expect plugins for Beancount or its web interface Fava to appear. These could add an “Ask AI” button to transactions. While at the time of writing there isn’t an official Beancount AI plugin, community interest is growing. In fact, Beancount’s creator noted the idea of an LLM prompt library for Beancount sounded fun, and community members are experimenting with “LLM accounting bots” and prompt engineering for accounting tasks. Keep an eye on Beancount forums and GitHub issues for such integrations.

• Open Source Libraries: Beyond Beanborg, other related tools include smart_importer (a Beancount plugin where you can write a Python function or even use simple machine learning to classify transactions on import). While not an LLM, it pairs well with LLM usage: you can use an LLM to quickly generate training data or rules, then let smart_importer apply them. There’s also interest in tools like Llamafile (an open-source local LLM for data tasks) being used to parse and convert financial data, and projects like Actual or Paisa in the plain-text accounting space (though these are more focused on providing a user interface, not AI). The landscape is evolving quickly, and it’s likely that more research projects and open-source code will emerge that specifically target accounting automation with LLMs. For example, a 2024 paper introduced a method to use domain-specific language prompts (Beancount syntax rules) to evaluate and improve LLM output for accounting – such research could lead to libraries that help an LLM adhere to accounting rules more strictly.

• Hybrid AI Workflows: You can combine LLMs with other AI/automation. For instance, use OCR to get text from receipts, then feed that to an LLM for entry generation. Or use an anomaly detection ML model to flag outliers, then have an LLM explain those outliers. The pieces can be connected via scripts or automation platforms (like using Zapier or custom code to send new transactions to an AI service and store the response).

When implementing, be mindful of costs and rate limits if using a paid API, especially for large ledgers (though categorizing a single transaction costs very few tokens). Also, incorporate error handling – e.g., if the AI returns an invalid account name or malformed entry, have fallbacks or manual review steps.

Existing Tools, Libraries, and Research

• Beanborg – As discussed, an automated transaction importer for Beancount that integrates rules, ML, and ChatGPT for categorization. It’s open-source and can serve as a template for building your own AI-assisted import workflows.

• smart_importer – A plugin for Beancount that lets you write Python logic to automatically classify or even fix transactions during import. Some users have used GPT to help craft these rules or to pre-classify data that smart_importer then uses.

• Beancount Prompt Engineering (Community) – There are ongoing community explorations in forums (Reddit’s r/plaintextaccounting, Beancount Google Group) about using LLMs. For instance, one user shared prompt techniques to get GPT-4 to output Beancount entries correctly by explicitly reminding it of format and using step-by-step reasoning. Another open GitHub gist provides a recipe for using GPT-4 or Claude to generate a Python function that categories transactions by keywords. These community experiments are valuable resources to learn prompt strategies.

• Financial LLM Research – Beyond practical scripts, research papers (like “Evaluating Financial Literacy of LLMs through DSLs for Plain Text Accounting”, FinNLP 2025) are directly looking at LLMs’ capability in double-entry bookkeeping. They often open-source their prompts or datasets, which could be repurposed to fine-tune or instruct models for better accuracy. There is also work on using LLM embeddings for anomaly detection in finance and on specialized finance-focused LLMs that might handle accounting queries more reliably. While these are not plug-and-play tools, they indicate the direction of future improvements.

• ChatGPT Plugins and Related SaaS – A few third-party services and plugins aim to integrate ChatGPT with accounting software (QuickBooks, Xero, etc.). For example, some plugins claim to “visually flag discrepancies” in QuickBooks via ChatGPT. For Beancount (being file-based and open), such plugins don’t exist yet, but a combination of an AI-friendly interface like Fava with a behind-the-scenes LLM could appear. Open-source enthusiasts might create a Fava extension that sends queries to an LLM (for instance, a Fava tab where you can ask questions about your ledger in natural language).

In summary, a mix of community scripts, dedicated tools like Beanborg, and cutting-edge research is pushing the envelope of how LLMs can assist in plain-text accounting. Even if a perfect off-the-shelf solution isn’t available for every task, the building blocks and examples are out there for technical users to assemble their own AI-augmented bookkeeping system.

Opportunities and Limitations of LLMs in Beancount Workflows

LLMs offer exciting opportunities for Beancount users:

• Dramatic efficiency gains: They can cut down the manual effort for categorizing and inputting transactions. Tasks that used to require writing custom code or rules can often be accomplished by simply asking the AI to do it. This lowers the barrier for non-programmers to automate their bookkeeping (“everyone can be a developer now” using ChatGPT). Business owners can focus more on reviewing financial insights rather than data entry.

• Adaptive learning: Unlike rigid rules, an LLM can generalize and handle edge cases. If you start spending in a new category, the AI might handle it gracefully by analogy to known categories. Moreover, if integrated properly, it could learn from corrections – e.g. if you override a suggestion, that information could be used to fine-tune future outputs (either manually or via a feedback loop in tools like Beanborg). This is akin to how one might train an assistant over time.

• Natural interaction: LLMs understand everyday language, making it possible to have conversational interfaces for accounting. Imagine asking, “What was my total spending on coffee this month?” and getting an answer or even a Beancount query constructed for you. While our focus has been on automation, the query capability is another benefit – ChatGPT can parse your question and, if given access to ledger data, formulate the result. This could augment Beancount reports by allowing ad-hoc Q&A in plain English.

However, there are important limitations and concerns to consider:

• Accuracy and Reliability: LLMs sound confident, but they may produce incorrect output if they misunderstand the task or lack proper constraints. In accounting, a single misclassification or imbalance can throw off reports. The research aforementioned found that without careful prompting, very few LLM-generated transactions were entirely correct. Even when the syntax is correct, the chosen category might be debatable. Thus, AI suggestions should be reviewed by a human accountant, especially in critical books. The mantra should be “trust, but verify.” Always use Beancount’s validation (e.g., bean-check for balance/syntax errors) on AI-generated entries.

• Privacy and Security: Financial data is sensitive. Many LLM solutions involve sending data to external servers (OpenAI, etc.). As one user pointed out, “ChatGPT could be a great account classifier... The only problem is privacy.” Sharing bank transactions with a third-party AI service may violate privacy policies or regulations, and there’s risk of data leaks. In fact, cases of accidental data exposure via cloud AI have been reported. To mitigate this, options include: using anonymized data (e.g., replace real names with placeholders when asking the AI), running LLMs locally (there are open-source models you can host that, while not as powerful as GPT-4, can handle simpler tasks), or using a hybrid approach (do initial processing locally, and perhaps only send high-level summaries to an API). Always ensure compliance with any data protection requirements relevant to your business.

• Cost and Performance: Using a state-of-the-art model like GPT-4 via API costs money per token. For occasional prompts this is negligible, but if you wanted to classify thousands of transactions, the cost adds up. There’s also latency – a large prompt with many transactions might take some time to process. Fine-tuned smaller models or open-source LLMs can be cheaper/faster, but might require more setup and may not reach the same accuracy without fine-tuning on your data. It’s a trade-off between convenience (cloud AI that “just works”) and control (local AI that you manage).

• Overfitting or Inconsistency: LLMs don’t have an inherent notion of your specific chart of accounts unless you embed that information in the prompt. They might invent account names that don’t exist in your ledger (as the earlier example, suggesting a new sub-account for “Laptop-Stand” when you might have preferred it under a general Office Supplies account). Keeping the AI’s suggestions in line with your established accounts may require providing a list of valid accounts as context or doing some post-processing to map its suggestions to the closest existing account. Similarly, if two different phrasings are used, the LLM might give inconsistent outputs. Establishing a standardized prompting method and possibly some “AI style guide” for your accounts can help maintain consistency.

• Scope of Understanding: While LLMs are great with text, they don’t do calculations with absolute precision. For instance, asking an LLM to compute financial ratios or do summations can yield mistakes due to the way they handle numbers (they’re not calculators by nature). In the context of Beancount, this means they might not be the best at tasks like ensuring all amounts in a complex multi-posting transaction sum correctly (though they usually can, simple arithmetic is within reach, but errors are possible). It’s wise to let Beancount itself do the math-heavy lifting (or verify totals) rather than relying on the AI’s arithmetic.

Despite these limitations, the trajectory is clearly towards more sophisticated and reliable AI helpers in accounting. The key is to use LLMs as assistants, not autonomous accountants. They excel at reducing drudgery – e.g. suggesting likely categorizations (saving your cognitive energy) and drafting entries or explanations. You remain the decision-maker who reviews and finalizes what goes into the books. As one accountant put it, “ChatGPT is far from perfect... but never before has it been so easy to write scripts without having to learn programming” – the same sentiment applies to bookkeeping tasks.

Conclusion

Large language models are proving to be valuable allies for those practicing plain-text accounting with Beancount. They bridge the gap between raw financial data and a neatly kept ledger by automating categorization, spotting anomalies, offering smart completions, translating natural language into entries, and easing reconciliation. Implementing LLMs in a Beancount workflow can bring significant efficiency gains and even open up Beancount to less-technical users (with the AI handling some of the scripting and formatting complexity behind the scenes).

For the technical audience of Beancount users, now is a great time to experiment with these AI tools. Try using ChatGPT or a local model to classify a week’s worth of uncategorized transactions, or to parse a new kind of statement you haven’t written an importer for. Leverage open-source projects like Beanborg for inspiration, and share your findings with the community. By combining the robustness of Beancount (which will keep your books accurate and auditable) with the power of LLMs (which can significantly reduce manual labor), you can achieve a bookkeeping workflow that is both efficient and flexible.

Ultimately, LLMs won’t replace the need for an accountant’s oversight or a business owner’s judgment, but they can augment these roles. They act as tireless assistants that can handle the grunt work in seconds and learn from each interaction. As the technology matures – addressing current limitations in accuracy and privacy – we can expect AI to become a standard part of the accountant’s toolkit. For now, with careful use, Beancount users can already harness LLMs to keep their books up-to-date with less effort and more insight. In short, let the robots do the repetitive bookkeeping, so humans can focus on understanding and decision-making.

Sources:

• Franz A. (2023). Accounting for busy people (with AI) – Blog post illustrating how ChatGPT can assist with Beancount by writing import scripts.
• Beancount Google Group (2023). “ChatGPT & Beancount” discussion – User experiment showing GPT-3 categorizing Amazon transactions with expense accounts.
• Fiandesio, L. (2025). Beanborg – Automatic AI-powered transactions categorizer for Beancount – GitHub README (open-source tool combining rules, ML, and ChatGPT for transaction import).
• Wafeq Blog (2023). How to Use ChatGPT in Bookkeeping – Overview of ChatGPT applications in bookkeeping (data entry, categorization, reconciliation, etc.).
• Jaan Li (2024). Cents & Sensibility: Accounting 101 with LLMs – GitHub Gist on prompting GPT-4 to categorize and convert transactions to Beancount format, noting privacy concerns.
• Harsh Daiya & Gaurav Puri (2024). Real-Time Anomaly Detection Using LLMs – DZone article explaining how LLMs detect contextual anomalies in finance (e.g., unusual spending patterns).
• Weber et al. (2025). Evaluating Financial Literacy of LLMs through DSLs for Plain Text Accounting – Research paper using Beancount to test LLM accuracy in generating accounting entries (finding only 8.33% completely correct without guidance).
• Beancount GitHub Issue #812 (2024). “LLM prompt library” discussion – Community plans for an LLM-based accounting bot and ideas for easy wins (e.g., auto-assigning QuickBooks codes via LLM).
• MindBridge (2024). AI-Powered Anomaly Detection: Going Beyond the Balance Sheet – Blog describing types of anomalies in financial data and AI’s role in detecting them (context for anomaly use-case).
• ShayCPA (2023). How to Safely Use ChatGPT for Accounting – Article noting one can use ChatGPT to match transactions and flag discrepancies during bank reconciliation. (Accessed via summary)