GST Reconciliation Software: GSTBot

The GSTR‑2B Reconciliation Engine

GSTBot solves the most labor‑intensive part of the Indian GST workflow: reconciling the purchase register with the GSTR‑2B return that the tax department publishes each month. Manual reconciliation is a month‑long exercise for small‑business finance teams; GSTBot replaces that with a deterministic, configurable algorithm that runs in seconds. This is where gst reconciliation software pays off in practice.

The problem

A typical SMB records hundreds of purchase invoices in a spreadsheet or a PDF collection. The tax portal provides a GSTR‑2B file that lists every invoice the supplier has filed. The two datasets rarely match perfectly: amounts may be rounded, vendor names may differ, and some invoices may be missing from the portal due to delays. Traditional tools insist on exact string matches and then flag every deviation as an exception, leaving users to decide what to do next.

The solution

GSTBot’s reconciliation engine uses a tolerance‑based matching strategy. Instead of requiring an exact amount, it accepts any GSTR‑2B line whose amount differs by no more than a configurable percentage. The default tolerance is 0.01 (1 %), but finance staff can adjust it in the UI or via the RECONCILIATION_TOLERANCE environment variable.

# FastAPI endpoint that kicks off a reconciliation job
@app.post("/reconcile")
async def reconcile(request: ReconcileRequest, db: Session = Depends(get_db)):
    task = celery_app.send_task(
        "tasks.reconcile_invoices",
        args=[request.invoice_ids],
        kwargs={"tolerance": request.tolerance},
    )
    return {"task_id": task.id}

The heavy lifting is performed in a Celery worker so the API remains responsive.

# tasks.py – the core reconciliation logic
@celery_app.task
def reconcile_invoices(invoice_ids, tolerance=0.01):
    invoices = db.query(Invoice).filter(Invoice.id.in_(invoice_ids)).all()
    gstr2b_entries = db.query(GSTR2BEntry).all()
    matches = []
    for inv in invoices:
        best = None
        for entry in gstr2b_entries:
            diff = abs(inv.amount - entry.amount) / entry.amount
            if diff <= tolerance:
                best = entry
                break
        if best:
            matches.append((inv.id, best.id))
        else:
            db.add(
                ExceptionRecord(
                    invoice_id=inv.id,
                    reason="No match within tolerance"
                )
            )
    db.commit()

The algorithm is intentionally simple so that it can be audited and tuned. It iterates over each invoice and looks for the first GSTR‑2B line that satisfies the tolerance condition. If none is found, the invoice is logged as an exception and surfaced to the user for manual review.

How it looks to the user

The React front‑end, built with Vite, presents the results in a table that can be filtered by vendor, amount, or exception type. A small component illustrates the typical layout: Getting gst reconciliation software right early saves rework later.

function MatchTable({matches}) {
  return (
    <table>
      <thead>
        <tr><th>Invoiceth><th>GSTR‑2B Entryth>tr>
      thead>
      <tbody>
        {matches.map(m => (
          <tr key={m.invoiceId}>
            <td>{m.invoiceId}td>
            <td>{m.gstrId}td>
          tr>
        ))}
      tbody>
    table>
  );
}

When the reconciliation completes, the table is populated with matched pairs. Unmatched invoices are listed in a separate pane with a recommended action: “Check vendor name spelling” or “Request supplier to file missing invoice.” The UI also shows a score that reflects the proportion of invoices matched, giving the finance team a quick health indicator.

Under the hood

• FastAPI handles the HTTP layer, exposing a lightweight JSON API.
• Python implements the matching logic; the code uses SQLAlchemy to query PostgreSQL.
• PostgreSQL stores the invoice data, GSTR‑2B entries, and exception records. Indexes on amount and vendor fields keep lookups fast.
• Redis acts as a cache for the most recent GSTR‑2B file, reducing database load when the same file is reconciled against multiple invoice batches.
• Celery queues reconciliation jobs so the user can continue working while the background worker processes the data.
• React and Vite provide a responsive, accessible interface that follows WCAG 2.1 AA guidelines.

The entire stack is open‑source, and the project lives on GitHub under the MIT license. The code base is structured so that contributors can add new matching heuristics—such as fuzzy vendor name matching—without touching the core logic.

Why it matters

For Indian SMBs, the cost of a manual reconciliation process can reach several thousand rupees per month. GSTBot reduces that cost by automating 90 % of the work and providing clear, actionable exceptions. Because the tolerance can be tuned, the tool adapts to the quality of the supplier data without compromising compliance. The result is a gst reconciliation software that feels like a natural extension of the existing accounting workflow, not a separate enterprise system.

GSTBot is available at https://gstbot.aiknol.com and the source code can be found on GitHub: https://github.com/r2st/GSTBot. The project is actively maintained and welcomes contributors who want to improve the reconciliation algorithms or add new compliance features.

Related reading

• GSTR-2B Reconciliation Made Simple
• Deep Dive: GST Reconciliation Software in GSTBot