Automate QuickBooks Invoice Creation with Python and the QBO API

If you bill the same 20 clients every month, you already know the drill: open QuickBooks, click "Create Invoice," retype the same line items, double check the amount, hit send, repeat 20 times. Automate QuickBooks invoice creation with Python and the QBO API, and that entire ritual becomes a script you run once a month—or schedule to run itself.

QuickBooks Online exposes a full REST API that lets you create customers, build invoices with line items, apply taxes, and even email the invoice directly to the client. Once you've connected Python to it, generating 20 invoices takes the same amount of time as generating one.

Why Manual Invoicing Doesn't Scale

Manual invoicing feels manageable at 5 clients. At 20, it eats an afternoon every billing cycle. At 50, most small businesses either hire a bookkeeper just for this task or start missing invoices entirely—which means missed revenue and cash flow gaps.

Beyond the time cost, manual invoicing introduces errors: wrong amounts, missing line items, invoices sent to the wrong contact, or duplicate invoices sent by two team members who didn't coordinate. Every error costs you a client email thread and a delayed payment.

Python automation removes the repetitive part while keeping you in control. You define the billing logic once—which clients get invoiced, what line items apply, what happens with recurring versus one-off charges—and let the script execute it consistently every cycle.

Setting Up the QuickBooks Online API Connection

Authentication with OAuth 2.0

QuickBooks Online uses OAuth 2.0. The python-quickbooks library, built on intuit-oauth, handles most of the token exchange for you:

1from intuitlib.client import AuthClient
2from quickbooks import QuickBooks
3
4auth_client = AuthClient(
5    client_id='YOUR_CLIENT_ID',
6    client_secret='YOUR_CLIENT_SECRET',
7    environment='production',
8    redirect_uri='https://yourapp.com/callback',
9)
10
11qb_client = QuickBooks(
12    auth_client=auth_client,
13    refresh_token='YOUR_REFRESH_TOKEN',
14    company_id='YOUR_REALM_ID',
15)

Store your refresh token securely (environment variables or a secrets manager)—QuickBooks refresh tokens are long-lived, so you won't need to re-authenticate every run once this is set up correctly.

Creating a Customer Lookup

Before creating invoices, build a lookup so you're referencing existing QuickBooks customer records instead of accidentally creating duplicates:

1from quickbooks.objects.customer import Customer
2
3customers = Customer.all(qb=qb_client)
4customer_lookup = {c.DisplayName: c.Id for c in customers}

Building the Invoice Generation Script

Defining Your Billing Data

Keep your billing data source simple and auditable—a CSV or Google Sheet works well for small teams, listing client name, line items, quantities, and rates:

1import pandas as pd
2
3billing_data = pd.read_csv('monthly_billing.csv')
4# Columns: client_name, description, quantity, rate

Creating the Invoice via the API

1from quickbooks.objects.invoice import Invoice, SalesItemLine, SalesItemLineDetail
2from quickbooks.objects.detailline import DetailLine
3
4def create_invoice(client_name, line_items):
5    invoice = Invoice()
6    invoice.CustomerRef = {"value": customer_lookup[client_name]}
7
8    for item in line_items:
9        line = SalesItemLine()
10        line.Amount = item['quantity'] * item['rate']
11        line.Description = item['description']
12        detail = SalesItemLineDetail()
13        detail.Qty = item['quantity']
14        detail.UnitPrice = item['rate']
15        line.SalesItemLineDetail = detail
16        invoice.Line.append(line)
17
18    invoice.save(qb=qb_client)
19    return invoice

Group your billing dataframe by client, build each client's line items, and call create_invoice() in a loop. Twenty invoices generate in seconds instead of an afternoon.

Emailing Invoices Automatically

QuickBooks can send the invoice directly through its own email system, keeping your sent-invoice history in one place:

1invoice.send(qb=qb_client)

This uses the customer's email on file and QuickBooks' own delivery, so replies and payment confirmations route back through the platform your bookkeeping already lives in.

Handling Recurring vs. One-Off Billing

Recurring Clients

For clients on a fixed monthly retainer, store their standard line items in a config file or database table, and run the script on a schedule (see our guide on scheduling Python scripts automatically) on the first of each month.

Variable/Usage-Based Billing

For clients billed by hours worked or units delivered, pull the source data first—time tracking exports, project management tool APIs, or a shared spreadsheet—calculate the billable amount, and feed that into the same create_invoice() function. The invoice creation logic stays identical; only the data source changes.

Handling Multi-Currency and International Clients

If you bill clients in multiple currencies, store each customer's preferred currency in QuickBooks and set it on the invoice object before saving—invoice.CurrencyRef = {"value": "EUR"}. QuickBooks Online handles the display and conversion tracking, but your billing data source should still store rates in the client's native currency to avoid rounding mismatches between your source spreadsheet and what QuickBooks ultimately records.

For clients billed through a payment processor integrated with QuickBooks, such as Stripe, you can extend the script to also create a matching payment link and attach it to the invoice object, so clients receive both the itemized invoice and a one-click way to pay it—reducing the days-sales-outstanding gap that often comes with manually emailed PDF invoices.

Handling Partial Payments and Credit Memos

Not every transaction is a straightforward full invoice. If you offer installment billing, split larger invoices into multiple Line entries representing payment milestones, or use QuickBooks' DepositToAccountRef to track partial payments received against an invoice already sent. For credit memos—refunding a client for a billing error or service credit—use the parallel CreditMemo object from the same library:

1from quickbooks.objects.creditmemo import CreditMemo
2
3def create_credit_memo(client_name, amount, reason):
4    memo = CreditMemo()
5    memo.CustomerRef = {"value": customer_lookup[client_name]}
6    line = SalesItemLine()
7    line.Amount = amount
8    line.Description = reason
9    memo.Line.append(line)
10    memo.save(qb=qb_client)
11    return memo

Keeping credit memos in the same automated pipeline as invoice creation means your books stay consistent without a separate manual process for corrections.

Handling International Clients and Tax Registration Numbers

If you bill clients across different tax jurisdictions, store each client's applicable tax registration number (VAT ID, GST number, or similar) in your billing data source and set it via the invoice's custom field mapping in QuickBooks. This keeps invoices compliant for cross-border billing without requiring manual entry of tax details on every invoice generated through the script.

Implementation Guide: Rolling This Out Safely

1. Start in sandbox mode with a handful of test clients to confirm line items, taxes, and customer references all map correctly before touching production data.
2. Run your first production batch manually, reviewing every generated invoice before it's emailed, rather than trusting the automation blindly on day one.
3. Compare against your prior manual process for one full billing cycle, checking that totals and client details match exactly.
4. Automate the schedule once you're confident, using a monthly cron job or Windows Task Scheduler entry to trigger the script automatically.
5. Build in a monthly review step where someone spot-checks a sample of generated invoices, even after the process is fully automated, to catch drift in your billing data source before it becomes a client-facing error.

Best Practices / Pro Tips

Always run the script in QuickBooks' sandbox environment first (environment='sandbox' in the AuthClient) before pointing it at production data. A bug that creates 20 wrong invoices in a live company file is a painful cleanup.

Log every invoice created—client name, amount, invoice number, and timestamp—to a separate audit file. If a client disputes a charge, you want a paper trail showing exactly what was sent and when.

Build in a dry-run mode that prints what would be invoiced without actually calling .save(). Review that output before every batch run, especially in the first few months while you're still validating the billing logic.

Conclusion

Automating QuickBooks invoice creation with Python turns a recurring administrative burden into a script that runs itself. Once connected via the QBO API, you can generate, itemize, and email dozens of invoices in the time it used to take to create one manually—with fewer errors and a complete audit trail behind every charge.

Start with your simplest recurring clients, validate the output in sandbox mode, and expand to variable billing once you trust the pipeline. Your future self, staring down a 50-client billing cycle, will thank you.

Frequently Asked Questions

Does this work with QuickBooks Desktop or only QuickBooks Online?

This approach is specific to QuickBooks Online, which has a modern REST API. QuickBooks Desktop uses a different integration method (QBXML via the SDK) that requires a different Python library and a different authentication flow.

How do I avoid creating duplicate customers in QuickBooks?

Always look up existing customers by DisplayName or a stored QuickBooks customer ID before creating a new one. Build your customer lookup at the start of each script run so you're referencing existing records rather than letting the API auto-create duplicates.

Can I automate late payment reminders too?

Yes. The QuickBooks API exposes invoice status, so you can query overdue invoices and trigger reminder emails through the same script, or route them into a tool like Zapier for follow-up sequences.

Is my QuickBooks data secure when accessed via API?

Yes, provided you follow OAuth best practices: store client secrets and refresh tokens in environment variables or a secrets manager, never commit them to source control, and restrict API scopes to only what your script needs.

What happens if the script fails partway through a batch of invoices?

Design the loop so each invoice creation is independent and logged immediately after success, rather than committing all 20 at the end. If the script fails on invoice 12, you'll have a log showing invoices 1-11 already succeeded, so you can resume from invoice 12 instead of risking duplicate invoices for clients already billed.

Related articles: Automate Invoice Processing with Python and OCR, Automate Expense Report Processing with Python, Schedule Python Scripts Automatically