Automating Invoice Processing in 10 Lines of TypeScript

Manual invoice processing is a classic business bottleneck. It's a tedious, time-consuming grind of opening emails, downloading attachments, deciphering PDF layouts, and manually punching data into accounting software. This repetitive work is not just slow—it's a breeding ground for costly errors, late payments, and employee burnout.

For years, traditional Robotic Process Automation (RPA) promised a solution. But this often meant building fragile bots that simply recorded mouse clicks and keyboard strokes. These bots are notoriously brittle; a minor UI update to your email client or accounting system can cause the entire automation to break, creating more maintenance headaches than it solves.

What if you could automate complex workflows like invoice processing with the same reliability and elegance as modern software development? What if you could do it in just a few lines of code?

Welcome to the future of RPA: Automation-as-Code. With a developer-first platform like rpa.do, you can transform complex business processes into simple, robust, and intelligent software agents.

The Old Way vs. The New Way

Imagine the typical invoice workflow:

1. An employee monitors the invoices@company.com inbox.
2. They open each new email and download the attached PDF invoice.
3. They open QuickBooks and navigate to the 'Create Bill' screen.
4. They manually copy the vendor name, invoice number, date, line items, and total amount from the PDF into the QuickBooks form.
5. They save the bill and archive the email.

A traditional RPA tool would try to mimic these steps exactly, creating a fragile script based on screen coordinates and UI element IDs.

The rpa.do approach is fundamentally different. Instead of mimicking human clicks, we use stable APIs and intelligent agents to execute the business logic directly. It's the difference between telling someone explicit driving directions and just giving them the destination address to plug into their GPS.

From Tedious Workflow to Simple API Call

Here’s how you can define and run that entire invoice processing workflow using the rpa.do TypeScript SDK. This isn't a simplified example—this is the actual code.

import { Agent } from '@do/rpa';

// Create an RPA agent to handle invoice processing
const invoiceAgent = new Agent('invoice-processor-agent');

// Define and run the automation workflow via a simple API call
async function runInvoiceProcessing() {
  const result = await invoiceAgent.run({
    workflow: 'process_new_invoices',
    source: {
      type: 'email_inbox',
      id: 'invoices@company.com'
    },
    destination: {
      type: 'quickbooks_api',
      action: 'create_bill'
    }
  });

  console.log(`Automation complete. ${result.processed} invoices processed.`);
}

runInvoiceProcessing();

Let's break down what's happening in these few powerful lines:

• const invoiceAgent = new Agent(...): We instantiate an intelligent software agent. This isn't a dumb bot; it's a dedicated worker designed for this specific task. It's configured securely within the .do platform, complete with any necessary credentials.
• await invoiceAgent.run({...}): This is where the magic happens. We're not scripting UI interactions. We're making a single, declarative API call that describes the what, not the how.
• source: { type: 'email_inbox', ... }: The agent knows how to securely connect to the specified email inbox and identify new invoices, abstracting away the complexities of email protocols.
• destination: { type: 'quickbooks_api', ... }: The agent uses the official QuickBooks API to create the bill. This direct system-to-system communication is infinitely more reliable than trying to navigate a graphical user interface.

This "Business-as-Code" approach means your automation is now as dependable and manageable as the rest of your software stack. It can be version-controlled in Git, peer-reviewed, and integrated into your CI/CD pipelines.

What Makes This So Powerful?

The simplicity of the code hides three revolutionary concepts that set rpa.do apart from traditional RPA.

1. AI-Native Intelligence

Our agents are more than just scripts. They are AI-native. When the invoiceAgent retrieves a PDF from an email, it doesn't just scrape text. It can leverage large language models (LLMs) to understand the document. This means it can handle different invoice layouts from various vendors without needing to be reprogrammed for each one. It intelligently extracts the vendor, invoice number, line items, and totals, even from unstructured data.

2. API-First Reliability

The core problem with old-school RPA is its reliance on fragile screen scraping. The rpa.do platform is built on an API-first philosophy. By interacting with services like email providers and accounting software through their official APIs, our agents create automations that are robust, scalable, and immune to superficial UI changes.

3. Secure and Maintainable by Design

How does the agent access your email and QuickBooks account? You don't hardcode credentials in your script. The .do platform includes a secure vault for all your API keys and passwords. The agent securely retrieves the credentials it needs at runtime, ensuring your secrets are never exposed in your code. This makes your automation both secure and easy to maintain.

Redefine Your Automation Strategy

Stop wrestling with brittle bots and complex visual designers. It’s time to empower your developers to solve business problems with the tools they already know and love. By treating workflow automation as a software engineering discipline, you can build solutions that are not only faster but fundamentally more reliable and intelligent.

Automating invoice processing is just the beginning. From data entry and report generation to complex system integrations, any rules-based digital process can be transformed into a simple, powerful API call.

Ready to start building intelligent automations that just work? Visit rpa.do to learn more about our developer-first, API-driven RPA platform.