The Problem: Drowning in Invoice Emails

If you’ve ever managed invoices manually, you know the struggle: emails flooding your inbox, sifting through attachments, and then forwarding the invoices and receipts to the accountant. It’s a time-consuming process that no one enjoys. I decided there had to be a better way.

Since I work at AutoKitteh, I’ve had the perfect opportunity to leverage the platform I contribute to. AutoKitteh makes it incredibly easy to create AI-driven workflows without dealing with complex infrastructure. Using it, I built an Invoice Processing System that automatically scans my inbox, detects invoices, extracts key details, and generates structured reports. Here's how I did it.

Github repo.

Try it in AutoKitteh.

The Solution: An AI-Powered Invoice Processor

I wanted my system to do three main things:

Detect invoices in incoming emails – Not every email contains an invoice, so I needed a way to filter them out.

Extract key invoice details – Company name, invoice ID, date, and amount had to be pulled automatically.

Generate structured reports – Instead of manually entering data into spreadsheets, I wanted a system that compiled everything for me.

With AutoKitteh, I could connect Gmail and ChatGPT, set up automation rules, and deploy the workflow in just a few steps. The entire setup took only a couple of hours, and Claude helped speed up the code generation process.

How It Works

Fetch emails from Gmail – The system monitors my inbox and pulls new emails.

Identify invoices using AI – ChatGPT analyzes the email content to determine if it contains an invoice.

Extract invoice details – The AI extracts key data such as company name, invoice number, date, and amount.

from autokitteh.google import gmail_client

def scan_gmail_messages(ts):
    """Scans Gmail for messages based on a timestamp (ts)."""
    date_from = datetime.fromtimestamp(ts, tz=UTC).strftime("%Y/%m/%d")
    messages = gmail.messages().list(userId="me", q=f"after:{date_from}").execute()
    emails = []

    for msg in messages.get("messages", []):
        message = gmail.messages().get(userId="me", id=msg["id"]).execute()
        subject, body, pdf_files, images = get_mail_content(message)


    attachments = []
    for pdf in pdf_files:
        attachment = {"filename": pdf["filename"], "data": pdf["data"]}
        attachments.append(attachment)

    mail_data = {
        "id": message["id"],
        "subject": subject,
        "body": body,
        "images": images or [],
        "attachments": attachments,
    }
    emails.append(mail_data)

    return emails

Generate structured JSON output – The extracted data is formatted into a clean JSON file.

Compile and send reports – The system organizes the data and generates a report, which is sent back to me.

The result? No more manual invoice processing. Everything is done automatically; I only need to review the final reports.

Here’s a snippet of the core workflow code that powers the invoice processor:

while True:
        # Wait for send_mail event or timeout.
        send_mail_req = autokitteh.next_event(send_mail_webhook, timeout=polling_interval)

        if send_mail_req:
            # Send invoice report on demand.
            print("Received send_mail event - sending invoice report")
            process_gmails.send_invoices(invoices)
        else:
            # Check for new invoices.
            new_invoices = process_gmails.handle_scan(last_check_time)


        if new_invoices:
            print(f"Found {len(new_invoices)} new invoices")
            invoices.extend(new_invoices)
        else:
            print("No new invoices found")

        last_check_time = int(time.time())

Autokitteh’s next_event makes event handling effortless by waiting for a specific trigger (like send_mail_webhook) without long polling. Unlike a manual setup that requires an event queue, background workers, and race condition handling, it simplifies real-time automation with just one line of code.

Building with Autokitteh

One of the best things about using Autokitteh was how easy it was to set everything up. I didn’t have to worry about API complexities, server management, or authentication headaches. The platform handled all of that.

Integrations: Connecting Gmail and ChatGPT took just a few clicks.

Workflow Automation: Defining invoice detection and data extraction logic was straightforward.

Deployment: With a single click, my project was live and running in the cloud.

It was like having my own AI-powered assistant handle invoices for me without writing complex backend code.

Autokitteh Durability

One of the key advantages of using Autokitteh is its durability. The system is designed to handle continuous invoice tracking throughout the month. Instead of relying solely on one-time processing, it allows users to request status updates at any point. This makes it perfect for generating a monthly summary while keeping track of invoices in real time. Whether you need to check progress mid-month or compile a final report, Autokitteh ensures seamless and durable automation.

Overcoming Challenges

While the system worked well, it wasn’t perfect. Here are some of the challenges I faced:

AI Accuracy: ChatGPT occasionally misclassified emails, either failing to detect an invoice or extracting incorrect details. I had to fine-tune my prompts and add validation checks.

Email Polling Delays: Since emails are processed at intervals, invoices aren’t always detected instantly. However, adjusting the polling frequency helped improve performance.

Attachment Handling: Some invoices were embedded as images rather than PDFs or text. I resolved this by converting them into AI-readable files for accurate processing.

Despite these challenges, the system can save hours of manual work every week, making invoice management much more efficient.

Future Improvements

While my current invoice processor is a huge productivity booster, I already have a few ideas for enhancements:

Interactive Slack Integration: Adding an interactive experience with Slack, allowing users to interact with the bot and get real-time updates on the current status of invoices.

Multi-Account Support: Right now, it only works with one Gmail account, but I’d love to expand it to multiple inboxes.

Better AI Training: Fine-tuning the model with additional training data could improve accuracy.

OCR for Scanned Invoices: Adding OCR support for images and scanned invoices would make the system even more powerful.

Integration with Accounting Software: Automating data entry into platforms like QuickBooks or Xero would be the ultimate time-saver.

Final Thoughts

Using Autokitteh to build my Invoice Processing System was an incredible experience. The platform’s powerful AI-driven automation transformed what used to be a tedious, repetitive task into a seamless, hands-free process. With Autokitteh’s intuitive workflow management, handling invoices has never been easier.

If you deal with invoice overload, it's time to put Autokitteh to work. This platform is built to streamline tasks, boost productivity, and let you focus on what truly matters.